FPGAの部屋

FPGAやCPLDの話題やFPGA用のツールの話題などです。 マニアックです。 日記も書きます。

FPGAの部屋の有用と思われるコンテンツのまとめサイトを作りました。ご利用ください。 http://marsee101.web.fc2.com/index.html

2013年09月

前回の”ラプラシアン・フィルタのCソフトをVivado HLSで”では、今まで、ラプラシアン・フィルタのCソフトウェアとして動作していたCソフトウェアをVivado HLSでそのままハード化しようというものだったが、エラーが発生してコンパイルすることが出来なかった。
今回は、3x3のラプラシアン・フィルタの式のみを、以前Vivado HLSのサンプルしてやってみた axi lite を元に変更してみようと思う。多分、計算式がとっても簡単なので、ハードウェア化のメリットは無いどころか、ソフトウェアよりも遅くなるかもしれないがやってみようと思う。
（2013/10/05：注　図などを大幅に書き換えました）

以前やった Vivado HLS のaix liteサンプルの記事を示す。

Vivado HLSのExampleを試してみる１（axi_lite の生成）
Vivado HLSのExampleを試してみる２（シミュレーションと合成）
Vivado HLSのExampleを試してみる３（インターフェイス）
Vivado HLSのExampleを試してみる４（C/RTL Cosimulation）
Vivado HLSのExampleを試してみる５（IPにした）
Vivado HLSで作ったaxi_lite IPをテストした


Vivado HLSのプロジェクトをxc7z020clg484-1で作った。
fbf2d1fd.png


Cのテストベンチを作製して、Cのシミュレーションを行った。結果は当然といえば当然に成功だった。
618606a4.png


C Synthesis ボタンをクリックして、CからHDLへの合成を行った。成功した。
しかし、FFが 330個、LUTが 582個、使用されている。多い気がする。8を掛けるところは、3ビット左シフトすればよいのでは？更にレイテンシ 2 クロックで、インターバルが 3 クロックなので、これではダメだ。パイプラインにしないとね。
fc9160c3.png


パイプラインにするために、PIPLINE Directive を入れよう。
右端のウインドウのDirective タブをクリックして、laplacian_filter の右クリックメニューから Insert Directive を選んだ。
303be9c8.png


Vivado HLS Directive Editor でPIPLINE Directive を選択して、Destination の Source File のラジオボタンをクリックした。OKボタンをクリックした。
18c47666.png


#pragma HLS PIPELINE が追加された。
1b248923.png


これで、C Synthesis ボタンをクリックして、CからHDLへの合成を行った。
レイテンシは 2 で変化がないが、インターバルが 1 になって、毎クロック、データを入力できるようになった。
FFは 491個で大幅に増えたが、LUTは 578個で少し減った。
e8c66400.png

”ソフトウエアのプロファイリング４（ハードウェアと同じ方式）”のラプラシアン・フィルタのCソフトウェアをVivado HLSでコンパイルしてHDLコードの落として使ってみたい。そのため、Cプログラムを修正してVivado HLSでプロジェクトを作製してコンパイルしてみた。

ZedBoard用のZynq7020のプロジェクトを作製して、Cプログラムを作製して、mmap() や munmap() を削除していった。表示されるエラーが無くなったところで、C Synthesis ボタンを押してコンパイルしたところエラーが発生した。

エラーの内容を下に示す。
@E [SYNCHK-41] image_lap_fil.c:61: unsupported pointer reinterpretation from type 'int' to type 'i32*' on variable 'r_addr'.
@I [SYNCHK-10] 1 error(s), 0 warning(s).


bb7dc31b.png


アンサーを検索したら、”Vivado HLS 2013.1: workaround for unsupported pointer reinterpretation”などがあったが、ポインタの扱いがダメなのかもしれない。ラプラシアン・フィルタの演算部はとっても簡単で、これだけCでというわけにも行き難いので、とりあえずはAXI4-Stream を使ったHDLで普通に作ってみようか？
AXI4-Stream入力があって、ラプラシアン・フィルタを通してからAXI4-Streamの出力しよう。AXI VDMAを使ってAXI4-Streamラプラシアン・フィルタIPにAXI4-Stream で入力して、出力をもう一度ラプラシアン・フィルタ用のフレーム・バッファに書き込めば良い。

Vivado HLSについてはチュートリアルをやってみようかな？と思っている。

最後に、Vivado HLSでコンパイルしたCソースを下に示す。（ただし、エラーでコンパイルできません）

// laplacian_filter.c
// RGBをYに変換後にラプラシアンフィルタを掛ける。
// ピクセルのフォーマットは、{8'd0, R(8bits), G(8bits), B(8bits)}, 1pixel = 32bits
// 2013/09/16

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <dirent.h>
#include <fcntl.h>
#include <assert.h>
#include <ctype.h>
#include <sys/stat.h>
#include <unistd.h>

#define HORIZONTAL_PIXEL_WIDTH    800
#define VERTICAL_PIXEL_WIDTH    600
#define ALL_PIXEL_VALUE    (HORIZONTAL_PIXEL_WIDTH*VERTICAL_PIXEL_WIDTH)

#define PAGE_SIZE (4*1024)
#define BLOCK_SIZE (4*1024)

#define BUFSIZE    1024

#define MEASURE_COUNT    5000

int laplacian_fil(int x0y0, int x1y0, int x2y0, int x0y1, int x1y1, int x2y1, int x0y2, int x1y2, int x2y2);
int conv_rgb2y(int rgb);
int chkhex(char *str);

int image_lap_fil(unsigned int fb_addr, unsigned int bitmap_dc_reg_addr)
{
     int xy[3][3];
    char buf[BUFSIZE], *token;
    unsigned int read_num;
    unsigned int next_frame_addr;
    unsigned int val;
    int lap_fil_val;
    int x, y;
    unsigned int r_addr, w_addr;
    unsigned int r_buf, w_buf, bitmap_buf;
    unsigned int line_buf[3][HORIZONTAL_PIXEL_WIDTH];
    int a, b;
    int fl, sl, tl;

    // ラプラシアンフィルタの結果を入れておくフレーム・バッファ
    next_frame_addr = ((fb_addr + (ALL_PIXEL_VALUE*4)) & (~(int)(PAGE_SIZE-1))) + PAGE_SIZE;

    // RGB値をY（輝度成分）のみに変換し、ラプラシアンフィルタを掛けた。
    for (y=0; y<VERTICAL_PIXEL_WIDTH; y++){
        for (x=0; x<HORIZONTAL_PIXEL_WIDTH; x++){
            if (y==0 || y==VERTICAL_PIXEL_WIDTH-1){ // 縦の境界の時の値は0とする
                lap_fil_val = 0;
            }else if (x==0 || x==HORIZONTAL_PIXEL_WIDTH-1){ // 横の境界の時も値は0とする
                lap_fil_val = 0;
            }else{
                if (y == 1 && x == 1){ // 最初のラインの最初のピクセルでは2ライン分の画素を読み出す
                    for (a=0; a<2; a++){ // 2ライン分
                        for (b=0; b<HORIZONTAL_PIXEL_WIDTH; b++){ // ライン
                            r_addr = fb_addr+((y+(a-1))*HORIZONTAL_PIXEL_WIDTH+b)*4;
                            line_buf[a][b] = *(volatile unsigned int *)r_addr;
                            line_buf[a][b] = conv_rgb2y(line_buf[a][b]);
                        }
                    }
                }
                if (x == 1) {    // ラインの最初なので、2つのピクセルを読み込む
                    for (b=0; b<2; b++){ // ライン
                        r_addr = fb_addr+((y+1)*HORIZONTAL_PIXEL_WIDTH+b)*4;
                        line_buf[(y+1)%3][b] = *(volatile unsigned int *)r_addr;
                        // (y+1)%3 は、使用済みのラインがに読み込む、y=2 の時 line[0], y=3の時 line[1], y=4の時 line[2]
                        line_buf[(y+1)%3][b] = conv_rgb2y(line_buf[(y+1)%3][b]);
                    }
                }

                // 1つのピクセルを読み込みながらラプラシアン・フィルタを実行する
                r_addr = fb_addr+((y+1)*HORIZONTAL_PIXEL_WIDTH+(x+1))*4; // ラプラシアン・フィルタに必要な最後のピクセルを読み込む
                line_buf[(y+1)%3][x+1] = *(volatile unsigned int *)r_addr;
                // (y+1)%3 は、使用済みのラインがに読み込む、y=2 の時 line[0], y=3の時 line[1], y=4の時 line[2]
                line_buf[(y+1)%3][x+1] = conv_rgb2y(line_buf[(y+1)%3][x+1]);

                fl = (y-1)%3;    // 最初のライン, y=1 012, y=2 120, y=3 201, y=4 012
                sl = y%3;        // 2番めのライン
                tl = (y+1)%3;    // 3番目のライン
                lap_fil_val = laplacian_fil(line_buf[fl][x-1], line_buf[fl][x], line_buf[fl][x+1], line_buf[sl][x-1], line_buf[sl][x], line_buf[sl][x+1], line_buf[tl][x-1], line_buf[tl][x], line_buf[tl][x+1]);
            }
            w_addr = next_frame_addr+(y*HORIZONTAL_PIXEL_WIDTH + x)*4;
             *(volatile unsigned int *)w_addr = (lap_fil_val<<16)+(lap_fil_val<<8)+lap_fil_val ;
            // printf("x = %d  y = %d", x, y);
        }
        a++;
    }

    // ラプラシアンフィルタの掛かった画像のスタートアドレスを bitmap-disp-cntrler-axi-master にセット
     *(volatile unsigned int *)bitmap_dc_reg_addr = next_frame_addr;

    return(0);
}


// RGBからYへの変換
// RGBのフォーマットは、{8'd0, R(8bits), G(8bits), B(8bits)}, 1pixel = 32bits
// 輝度信号Yのみに変換する。変換式は、Y =  0.299R + 0.587G + 0.114B
// "YUVフォーマット及び YUV<->RGB変換"を参考にした。http://vision.kuee.kyoto-u.ac.jp/~hiroaki/firewire/yuv.html
//　2013/09/27 : float を止めて、すべてint にした
int conv_rgb2y(int rgb){
    int r, g, b, y_f;
    int y;

    b = rgb & 0xff;
    g = (rgb>>8) & 0xff;
    r = (rgb>>16) & 0xff;

    y_f = 77*r + 150*g + 29*b; //y_f = 0.299*r + 0.587*g + 0.114*b;の係数に256倍した
    y = y_f >> 8; // 256で割る

    return(y);
}

// ラプラシアンフィルタ
// x0y0 x1y0 x2y0 -1 -1 -1
// x0y1 x1y1 x2y1 -1  8 -1
// x0y2 x1y2 x2y2 -1 -1 -1
int laplacian_fil(int x0y0, int x1y0, int x2y0, int x0y1, int x1y1, int x2y1, int x0y2, int x1y2, int x2y2)
{
     return(abs(-x0y0 -x1y0 -x2y0 -x0y1 +8*x1y1 -x2y1 -x0y2 -x1y2 -x2y2));
}

// 文字列が16進数かを調べる
int chkhex(char *str){
    while (*str != '\0'){
        if (!isxdigit(*str))
            return 0;
        str++;
    }
    return 1;
}


”ソフトウエアのプロファイリング３（最適化）”で、ハードウェアの実装と近い形にしてきたが、更にハードウェアの実装に近づけることにする。

今度は、フレームの最初に2ラインを読んでから、2つピクセルを保存した後で、1つピクセルを読みながら、真ん中のラプラシアン・フィルタの値を計算していく。これで、”画像のエッジ検出６（3X3での方式の検討）”で実装したハードウェアと同じ方式になった。
実行したところ、”ソフトウエアのプロファイリング３（最適化）”よりも、更に 5msec ほど速くなった。（2013/10/08 注：gettimeofday()の使い方を間違っていたためマイナスの値が出たようだ）

zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = 434225 usec
zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = 433856 usec
zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = 433856 usec
zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = -565756 usec
zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = 433745 usec


更にハードウェア化の障害になるのは conv_rgb2y() 関数で使用している float だ。これを int に変換する。係数が小数なので、256倍して整数に変換し、結果を256で割ることにした。これで、ラプラシアン・フィルタを実行したところ、更に、45msec ほど速くなった。（2013/10/08 注：gettimeofday()の使い方を間違っていたためマイナスの値が出たようだ。測定値を貼り直す）

zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = 0.391241 sec
zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = 0.391315 sec
zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = 0.392016 sec
zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = 0.391776 sec
zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = 0.391168 sec


Cソースコードを下に貼っておく。（2013/10/08 注：gettimeofday()の使い方を間違っていたためマイナスの値が出たようだ。Cソースを貼り直す）”時間・時刻処理について(4)”を参照させて頂いた。

// laplacian_filter.c
// RGBをYに変換後にラプラシアンフィルタを掛ける。
// ピクセルのフォーマットは、{8'd0, R(8bits), G(8bits), B(8bits)}, 1pixel = 32bits
// 2013/09/16

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <dirent.h>
#include <fcntl.h>
#include <assert.h>
#include <ctype.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <linux/kernel.h>

#define HORIZONTAL_PIXEL_WIDTH    800
#define VERTICAL_PIXEL_WIDTH    600
#define ALL_PIXEL_VALUE    (HORIZONTAL_PIXEL_WIDTH*VERTICAL_PIXEL_WIDTH)

#define PAGE_SIZE (4*1024)
#define BLOCK_SIZE (4*1024)

#define BUFSIZE    1024

#define MEASURE_COUNT    5000

int laplacian_fil(int x0y0, int x1y0, int x2y0, int x0y1, int x1y1, int x2y1, int x0y2, int x1y2, int x2y2);
int conv_rgb2y(int rgb);
int chkhex(char *str);
volatile unsigned *setup_io(off_t mapped_addr, unsigned int *buf_addr);
void Xil_DCacheInvalidateLine(unsigned int adr);
void Xil_DCacheFlushLine(unsigned int adr);

int main()
{
    FILE *fd;
    int xy[3][3];
    char buf[BUFSIZE], *token;
    unsigned int read_num;
    unsigned int bitmap_dc_reg_addr;
    volatile unsigned *bm_disp_cnt_reg;
    unsigned int fb_addr, next_frame_addr;
    unsigned int val;
    int lap_fil_val;
    int x, y;
    int *r_pixel, *w_pixel;
    unsigned int r_addr, w_addr;
    unsigned int r_addr_page, w_addr_page;
    unsigned int r_addr_page_pre=0, w_addr_page_pre=0;
    unsigned int r_addr_offset, w_addr_offset;
    unsigned int r_buf, w_buf, bitmap_buf;
    struct timeval start_time, temp1, temp2, end_time;
    unsigned int rmmap_cnt=0, wmmap_cnt=0;
    unsigned int line_buf[3][HORIZONTAL_PIXEL_WIDTH];
    int a, b;
    int fl, sl, tl;

    gettimeofday(&start_time, NULL);    // プログラム起動時の時刻を記録
    // fb_start_addr.txt の内容をパイプに入れる
    memset(buf, '\0', sizeof(buf)); // buf すべてに\0 を入れる
    // fb_start_addr.txt を開く
    fd = popen("cat /Apps/fb_start_addr.txt", "r");
    if (fd != NULL){
        read_num = fread(buf, sizeof(unsigned char), BUFSIZE, fd);
        if (read_num > 0){
            sscanf(buf, "%x\n", &fb_addr);
        }
    }
    pclose(fd);

    // ラプラシアンフィルタの結果を入れておくフレーム・バッファ
    next_frame_addr = ((fb_addr + (ALL_PIXEL_VALUE*4)) & (~(int)(PAGE_SIZE-1))) + PAGE_SIZE;

    // RGB値をY（輝度成分）のみに変換し、ラプラシアンフィルタを掛けた。
    for (y=0; y<VERTICAL_PIXEL_WIDTH; y++){
        for (x=0; x<HORIZONTAL_PIXEL_WIDTH; x++){
            if (y==0 || y==VERTICAL_PIXEL_WIDTH-1){ // 縦の境界の時の値は0とする
                lap_fil_val = 0;
            }else if (x==0 || x==HORIZONTAL_PIXEL_WIDTH-1){ // 横の境界の時も値は0とする
                lap_fil_val = 0;
            }else{
                if (y == 1 && x == 1){ // 最初のラインの最初のピクセルでは2ライン分の画素を読み出す
                    for (a=0; a<2; a++){ // 2ライン分
                        for (b=0; b<HORIZONTAL_PIXEL_WIDTH; b++){ // ライン
                            r_addr = fb_addr+((y+(a-1))*HORIZONTAL_PIXEL_WIDTH+b)*4;
                            r_addr_page = r_addr & (~(int)(PAGE_SIZE-1));
                            r_addr_offset = r_addr & ((int)(PAGE_SIZE-1));
                            if (r_addr_page != r_addr_page_pre){    // 以前のページと違うのでunmmap してページの物理アドレスを取り直す
                               if (r_addr_page_pre != 0){    // 初めの場合はmmap()していないので、munmap()しない
                                    munmap(r_pixel, BLOCK_SIZE);
                                    free((unsigned int *)r_buf);
                                }
                                r_pixel = setup_io((off_t)r_addr_page, &r_buf);
                                
                                rmmap_cnt++;
                                r_addr_page_pre = r_addr_page;
                            }
                            line_buf[a][b] = *(volatile int *)((unsigned int)r_pixel + r_addr_offset);
                            line_buf[a][b] = conv_rgb2y(line_buf[a][b]);
                        }
                    }
                }
                if (x == 1) {    // ラインの最初なので、2つのピクセルを読み込む
                    for (b=0; b<2; b++){ // ライン
                        r_addr = fb_addr+((y+1)*HORIZONTAL_PIXEL_WIDTH+b)*4;
                        r_addr_page = r_addr & (~(int)(PAGE_SIZE-1));
                        r_addr_offset = r_addr & ((int)(PAGE_SIZE-1));
                        if (r_addr_page != r_addr_page_pre){    // 以前のページと違うのでunmmap してページの物理アドレスを取り直す
                           if (r_addr_page_pre != 0){    // 初めの場合はmmap()していないので、munmap()しない
                                munmap(r_pixel, BLOCK_SIZE);
                                free((unsigned int *)r_buf);
                            }
                            r_pixel = setup_io((off_t)r_addr_page, &r_buf);
                                
                            rmmap_cnt++;
                            r_addr_page_pre = r_addr_page;
                        }
                        line_buf[(y+1)%3][b] = *(volatile int *)((unsigned int)r_pixel + r_addr_offset);
                        // (y+1)%3 は、使用済みのラインがに読み込む、y=2 の時 line[0], y=3の時 line[1], y=4の時 line[2]
                        line_buf[(y+1)%3][b] = conv_rgb2y(line_buf[(y+1)%3][b]);
                    }
                }
                
                // 1つのピクセルを読み込みながらラプラシアン・フィルタを実行する
                r_addr = fb_addr+((y+1)*HORIZONTAL_PIXEL_WIDTH+(x+1))*4; // ラプラシアン・フィルタに必要な最後のピクセルを読み込む
                r_addr_page = r_addr & (~(int)(PAGE_SIZE-1));
                r_addr_offset = r_addr & ((int)(PAGE_SIZE-1));
                if (r_addr_page != r_addr_page_pre){    // 以前のページと違うのでunmmap してページの物理アドレスを取り直す
                   if (r_addr_page_pre != 0){    // 初めの場合はmmap()していないので、munmap()しない
                        munmap(r_pixel, BLOCK_SIZE);
                        free((unsigned int *)r_buf);
                    }
                    r_pixel = setup_io((off_t)r_addr_page, &r_buf);
                        
                    rmmap_cnt++;
                    r_addr_page_pre = r_addr_page;
                }
                line_buf[(y+1)%3][x+1] = *(volatile int *)((unsigned int)r_pixel + r_addr_offset);
                // (y+1)%3 は、使用済みのラインがに読み込む、y=2 の時 line[0], y=3の時 line[1], y=4の時 line[2]
                line_buf[(y+1)%3][x+1] = conv_rgb2y(line_buf[(y+1)%3][x+1]);
                
                fl = (y-1)%3;    // 最初のライン, y=1 012, y=2 120, y=3 201, y=4 012
                sl = y%3;        // 2番めのライン
                tl = (y+1)%3;    // 3番目のライン
                lap_fil_val = laplacian_fil(line_buf[fl][x-1], line_buf[fl][x], line_buf[fl][x+1], line_buf[sl][x-1], line_buf[sl][x], line_buf[sl][x+1], line_buf[tl][x-1], line_buf[tl][x], line_buf[tl][x+1]);
            }
            w_addr = next_frame_addr+(y*HORIZONTAL_PIXEL_WIDTH + x)*4;
            w_addr_page = w_addr & (~(int)(PAGE_SIZE-1));
            w_addr_offset = w_addr & ((int)(PAGE_SIZE-1));
            if (w_addr_page != w_addr_page_pre){    // 以前のページと違うのでunmmap してページの物理アドレスを取り直す
                if (w_addr_page_pre != 0){    // 初めの場合はmmap()していないので、munmap()しない
                    munmap(w_pixel, BLOCK_SIZE);
                    free((unsigned int *)w_buf);
                }
                w_pixel = setup_io((off_t)w_addr_page, &w_buf);
                wmmap_cnt++;
                w_addr_page_pre = w_addr_page;
            }
            *(volatile int *)((unsigned int)w_pixel + w_addr_offset) = (lap_fil_val<<16)+(lap_fil_val<<8)+lap_fil_val ;
            // printf("x = %d  y = %d", x, y);
        }
        a++;
    }
    munmap((unsigned int *)r_addr_page, BLOCK_SIZE);
    free((unsigned int *)r_buf);
    munmap((unsigned int *)w_addr_page, BLOCK_SIZE);
    free((unsigned int *)w_buf);

    // bitmap-disp-cntrler-axi-master　のアドレスを取得
    memset(buf, '\0', sizeof(buf)); // buf すべてに\0 を入れる
    // ls /sys/devices/axi.0 の内容をパイプに入れる
    fd = popen("ls /sys/devices/axi.0", "r");
    if (fd != NULL){
        read_num = fread(buf, sizeof(unsigned char), BUFSIZE, fd);
        if (read_num > 0){
            token = buf;
            if ((token=strtok(token, ".\n")) != NULL){
                do {
                    if (chkhex(token)){ // 16進数
                        sscanf(token, "%x", &val);
                    } else {
                        if (strcmp(token, "bitmap-disp-cntrler-axi-master") == 0)
                            bitmap_dc_reg_addr = val;
                    }
                }while((token=strtok(NULL, ".\n")) != NULL);
            }
        }
    }
    pclose(fd);

    // ラプラシアンフィルタの掛かった画像のスタートアドレスを bitmap-disp-cntrler-axi-master にセット
    bm_disp_cnt_reg = setup_io((off_t)bitmap_dc_reg_addr, &bitmap_buf);
    *bm_disp_cnt_reg = next_frame_addr;

    munmap((unsigned int *)bm_disp_cnt_reg, BLOCK_SIZE);
    free((unsigned int *)bitmap_buf);

    gettimeofday(&end_time, NULL);
    printf("rmmap_cnt = %d\n", rmmap_cnt);
    printf("wmmap_cnt = %d\n", wmmap_cnt);
    if (end_time.tv_usec < start_time.tv_usec) {
        printf("total time = %d.%d sec\n", end_time.tv_sec - start_time.tv_sec - 1, 1000000 + end_time.tv_usec - start_time.tv_usec);
    }
    else {
        printf("total time = %d.%d sec\n", end_time.tv_sec - start_time.tv_sec, end_time.tv_usec - start_time.tv_usec);
    }
    return(0);
}


// RGBからYへの変換
// RGBのフォーマットは、{8'd0, R(8bits), G(8bits), B(8bits)}, 1pixel = 32bits
// 輝度信号Yのみに変換する。変換式は、Y =  0.299R + 0.587G + 0.114B
// "YUVフォーマット及び YUV<->RGB変換"を参考にした。http://vision.kuee.kyoto-u.ac.jp/~hiroaki/firewire/yuv.html
//　2013/09/27 : float を止めて、すべてint にした
int conv_rgb2y(int rgb){
    int r, g, b, y_f;
    int y;

    b = rgb & 0xff;
    g = (rgb>>8) & 0xff;
    r = (rgb>>16) & 0xff;

    y_f = 77*r + 150*g + 29*b; //y_f = 0.299*r + 0.587*g + 0.114*b;の係数に256倍した
    y = y_f >> 8; // 256で割る

    return(y);
}

// ラプラシアンフィルタ
// x0y0 x1y0 x2y0 -1 -1 -1
// x0y1 x1y1 x2y1 -1  8 -1
// x0y2 x1y2 x2y2 -1 -1 -1
int laplacian_fil(int x0y0, int x1y0, int x2y0, int x0y1, int x1y1, int x2y1, int x0y2, int x1y2, int x2y2)
{
     return(abs(-x0y0 -x1y0 -x2y0 -x0y1 +8*x1y1 -x2y1 -x0y2 -x1y2 -x2y2));
}

//
// Set up a memory regions to access GPIO
//
volatile unsigned *setup_io(off_t mapped_addr, unsigned int *buf_addr)
// void setup_io()
{
    int  mem_fd;
    char *gpio_mem, *gpio_map;

   /* open /dev/mem */
   if ((mem_fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0) {
      printf("can't open /dev/mem \n");
      printf("mapped_addr = %x\n", mapped_addr);
      exit (-1);
   }

   /* mmap GPIO */

   // Allocate MAP block
   if ((gpio_mem = malloc(BLOCK_SIZE + (PAGE_SIZE-1))) == NULL) {
      printf("allocation error \n");
      exit (-1);
   }
    *buf_addr = gpio_mem;    // mallocしたアドレスをコピー

   // Make sure pointer is on 4K boundary
   if ((unsigned long)gpio_mem % PAGE_SIZE)
     gpio_mem += PAGE_SIZE - ((unsigned long)gpio_mem % PAGE_SIZE);

   // Now map it
   gpio_map = (unsigned char *)mmap(
      (caddr_t)gpio_mem,
      BLOCK_SIZE,
      PROT_READ|PROT_WRITE,
      MAP_SHARED|MAP_FIXED,
      mem_fd,
      mapped_addr
   );

   if ((long)gpio_map < 0) {
      printf("mmap error %d\n", (int)gpio_map);
      printf("mapped_addr = %x\n", mapped_addr);
      exit (-1);
   }

   close(mem_fd); // /dev/mem のクローズ

   // Always use volatile pointer!
   // gpio = (volatile unsigned *)gpio_map;
   return((volatile unsigned *)gpio_map);

} // setup_io

// 文字列が16進数かを調べる
int chkhex(char *str){
    while (*str != '\0'){
        if (!isxdigit(*str))
            return 0;
        str++;
    }
    return 1;
}


”ソフトウエアのプロファイリング２（mmap(), munmap() の時間計測２）”の続き。

ラプラシアン・フィルタの実行時間を139秒から37秒に最適化してきたが（順番が逆になったけど、そこは勘弁して頂いて。。。）、今回は更に最適化を図る。mmap(), munmap() が遅いので、極力少なくすることを考える。
前回の計算式から mmap(), munmap() を除いた実行時間は約2秒だった。そこを目指すことになるが、それよりも早くなることもあるかも知れない。

今回の最適化は、ハードウェアの実装により近くなる。ハードウェアの実装は、”画像のエッジ検出６（3X3での方式の検討）”を参照して欲しい。ここでは、2ライン分のピクセルデータをライン・バッファに蓄えて3ライン分のピクセルデータが3つたまったところで真ん中のピクセルのラプラシアン・フィルタの出力値を計算している。ハードウェアはクロックごとにピクセルデータが来て、それを1フレーム分溜めておくのが難しい。更に溜めてもReadのレイテンシが発生してしまう。そこで、2ライン分はFPGA内部の速度の早いBlockRAMに溜めておいて、それを読み出しながら、現在カメラから来るピクセルデータをDFFで遅延させながらラプラシアン・フィルタを掛けるわけだ。クロックごとに処理するのが前提となっている。
ソフトウェアはと言うと、クロックごとに処理を完了するという、厳しい条件は無いが、なるべく早く処理したいという希望があるだろう。現在のカメラのフレーム・レートは15fpsなので、66.7msec ごとにラプラシアン・フィルタを掛けることができれば、実時間処理ができるということになる。

今回のラプラシアン・フィルタの実装は、3ライン分読んでからラプラシアン・フィルタを掛けるようにした。これで、ピクセルデータRead時のアドレスは連続するので、Readのmmap(), munmap() の数とWriteのmmap(), munmap() の数は等しくなるはずだ。最初は3ライン分のピクセルをReadするが、次からは後にReadした2ラインは使用できるので、1ラインだけのReadになる。

結果は値がマイナスになることがあるのだが、+の値を見ると約0.4秒となった。これは、”ソフトウエアのプロファイリング２（mmap(), munmap() の時間計測２）”で計算した約2秒よりも小さい。これは何故かと考えると、1ラインを連続的にReadしているので、キャシュラインをフィルするIO命令が連続的に発行されて、DDR3コントローラで連続的にバーストで読んでこられているのではないだろうか？読んだ値は少なくとも2ndキャッシュには入ると思うので、複数回読まれる値はキャッシュから読めるのではないだろうか？そのため、ラプラシアン・フィルタの実行時間本体が最適化されて速くなったのではないだろうか？これらはあくまでも推測で、想像の域を超えていないことをお断りしておく。PS内部をChipScope で見えればよいのだが？

下に、データを示す。－になってしまうのはなぜだろうか？

zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = 439478 usec
zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = 439385 usec
zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = -560927 usec
zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = -560688 usec
zynq> ./laplacian_filter.elf
rmmap_cnt = 469
wmmap_cnt = 469
total time = 438869 usec


Read用の mmap(), munmap() とWrite用の mmap(), munmap() の回数は同じ469回だった。 mmap(), munmap() の回数は、469回 x 2 x 28usec ≒ 26.3msec となり、全体の割合はそれほど大きく無くなった。

ラプラシアン・フィルタの実行時間は、139秒が39秒になって、更に0.4秒に最適化出来た。
下に現在のCソースコードを示す。

// laplacian_filter.c
// RGBをYに変換後にラプラシアンフィルタを掛ける。
// ピクセルのフォーマットは、{8'd0, R(8bits), G(8bits), B(8bits)}, 1pixel = 32bits
// 2013/09/16

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <dirent.h>
#include <fcntl.h>
#include <assert.h>
#include <ctype.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <linux/kernel.h>

#define HORIZONTAL_PIXEL_WIDTH    800
#define VERTICAL_PIXEL_WIDTH    600
#define ALL_PIXEL_VALUE    (HORIZONTAL_PIXEL_WIDTH*VERTICAL_PIXEL_WIDTH)

#define PAGE_SIZE (4*1024)
#define BLOCK_SIZE (4*1024)

#define BUFSIZE    1024

#define MEASURE_COUNT    5000

int laplacian_fil(int x0y0, int x1y0, int x2y0, int x0y1, int x1y1, int x2y1, int x0y2, int x1y2, int x2y2);
int conv_rgb2y(int rgb);
int chkhex(char *str);
volatile unsigned *setup_io(off_t mapped_addr, unsigned int *buf_addr);
void Xil_DCacheInvalidateLine(unsigned int adr);
void Xil_DCacheFlushLine(unsigned int adr);

int main()
{
    FILE *fd;
    int xy[3][3];
    char buf[BUFSIZE], *token;
    unsigned int read_num;
    unsigned int bitmap_dc_reg_addr;
    volatile unsigned *bm_disp_cnt_reg;
    unsigned int fb_addr, next_frame_addr;
    unsigned int val;
    int lap_fil_val;
    int x, y;
    int *r_pixel, *w_pixel;
    unsigned int r_addr, w_addr;
    unsigned int r_addr_page, w_addr_page;
    unsigned int r_addr_page_pre=0, w_addr_page_pre=0;
    unsigned int r_addr_offset, w_addr_offset;
    unsigned int r_buf, w_buf, bitmap_buf;
    struct timeval start_time, temp1, temp2, end_time;
    unsigned int rmmap_cnt=0, wmmap_cnt=0;
    unsigned int line_buf[3][HORIZONTAL_PIXEL_WIDTH];
    int a, b;
    int fl, sl, tl;

    gettimeofday(&start_time, NULL);    // プログラム起動時の時刻を記録
    // fb_start_addr.txt の内容をパイプに入れる
    memset(buf, '\0', sizeof(buf)); // buf すべてに\0 を入れる
    // fb_start_addr.txt を開く
    fd = popen("cat /Apps/fb_start_addr.txt", "r");
    if (fd != NULL){
        read_num = fread(buf, sizeof(unsigned char), BUFSIZE, fd);
        if (read_num > 0){
            sscanf(buf, "%x\n", &fb_addr);
        }
    }
    pclose(fd);

    // ラプラシアンフィルタの結果を入れておくフレーム・バッファ
    next_frame_addr = ((fb_addr + (ALL_PIXEL_VALUE*4)) & (~(int)(PAGE_SIZE-1))) + PAGE_SIZE;

    // RGB値をY（輝度成分）のみに変換し、ラプラシアンフィルタを掛けた。
    for (y=0; y<VERTICAL_PIXEL_WIDTH; y++){
        for (x=0; x<HORIZONTAL_PIXEL_WIDTH; x++){
            if (y==0 || y==VERTICAL_PIXEL_WIDTH-1){ // 縦の境界の時の値は0とする
                lap_fil_val = 0;
            }else if (x==0 || x==HORIZONTAL_PIXEL_WIDTH-1){ // 横の境界の時も値は0とする
                lap_fil_val = 0;
            }else{
                if (x == 1){ // ラインの最初でラインの画素を読み出す
                    if (y == 1){ // 最初のラインでは3ライン分の画素を読み出す
                        for (a=0; a<3; a++){ // 3ライン分
                            for (b=0; b<HORIZONTAL_PIXEL_WIDTH; b++){ // ライン
                                r_addr = fb_addr+((y+(a-1))*HORIZONTAL_PIXEL_WIDTH+b)*4;
                                r_addr_page = r_addr & (~(int)(PAGE_SIZE-1));
                                r_addr_offset = r_addr & ((int)(PAGE_SIZE-1));
                                if (r_addr_page != r_addr_page_pre){    // 以前のページと違うのでunmmap してページの物理アドレスを取り直す
                                   if (r_addr_page_pre != 0){    // 初めの場合はmmap()していないので、munmap()しない
                                        munmap(r_pixel, BLOCK_SIZE);
                                        free((unsigned int *)r_buf);
                                    }
                                    r_pixel = setup_io((off_t)r_addr_page, &r_buf);
                                    
                                    rmmap_cnt++;
                                    r_addr_page_pre = r_addr_page;
                                }
                                line_buf[a][b] = *(volatile int *)((unsigned int)r_pixel + r_addr_offset);
                                line_buf[a][b] = conv_rgb2y(line_buf[a][b]);
                            }
                        }
                    } else { // 最初のラインではないので、1ラインだけ読み込む。すでに他の2ラインは読み込まれている
                           for (b=0; b<HORIZONTAL_PIXEL_WIDTH; b++){ // ライン
                            r_addr = fb_addr+((y+1)*HORIZONTAL_PIXEL_WIDTH+b)*4;
                            r_addr_page = r_addr & (~(int)(PAGE_SIZE-1));
                            r_addr_offset = r_addr & ((int)(PAGE_SIZE-1));
                            if (r_addr_page != r_addr_page_pre){    // 以前のページと違うのでunmmap してページの物理アドレスを取り直す
                               if (r_addr_page_pre != 0){    // 初めの場合はmmap()していないので、munmap()しない
                                    munmap(r_pixel, BLOCK_SIZE);
                                    free((unsigned int *)r_buf);
                                }
                                r_pixel = setup_io((off_t)r_addr_page, &r_buf);
                                    
                                rmmap_cnt++;
                                r_addr_page_pre = r_addr_page;
                            }
                            line_buf[(y+1)%3][b] = *(volatile int *)((unsigned int)r_pixel + r_addr_offset);
                            // (y+1)%3 は、使用済みのラインがに読み込む、y=2 の時 line[0], y=3の時 line[1], y=4の時 line[2]
                            line_buf[(y+1)%3][b] = conv_rgb2y(line_buf[(y+1)%3][b]);
                        }
                    }
                }
                fl = (y-1)%3;    // 最初のライン, y=1 012, y=2 120, y=3 201, y=4 012
                sl = y%3;        // 2番めのライン
                tl = (y+1)%3;    // 3番目のライン
                lap_fil_val = laplacian_fil(line_buf[fl][x-1], line_buf[fl][x], line_buf[fl][x+1], line_buf[sl][x-1], line_buf[sl][x], line_buf[sl][x+1], line_buf[tl][x-1], line_buf[tl][x], line_buf[tl][x+1]);
            }
            w_addr = next_frame_addr+(y*HORIZONTAL_PIXEL_WIDTH + x)*4;
            w_addr_page = w_addr & (~(int)(PAGE_SIZE-1));
            w_addr_offset = w_addr & ((int)(PAGE_SIZE-1));
            if (w_addr_page != w_addr_page_pre){    // 以前のページと違うのでunmmap してページの物理アドレスを取り直す
                if (w_addr_page_pre != 0){    // 初めの場合はmmap()していないので、munmap()しない
                    munmap(w_pixel, BLOCK_SIZE);
                    free((unsigned int *)w_buf);
                }
                w_pixel = setup_io((off_t)w_addr_page, &w_buf);
                wmmap_cnt++;
                w_addr_page_pre = w_addr_page;
            }
            *(volatile int *)((unsigned int)w_pixel + w_addr_offset) = (lap_fil_val<<16)+(lap_fil_val<<8)+lap_fil_val ;
            // printf("x = %d  y = %d", x, y);
        }
    }
    munmap((unsigned int *)r_addr_page, BLOCK_SIZE);
    free((unsigned int *)r_buf);
    munmap((unsigned int *)w_addr_page, BLOCK_SIZE);
    free((unsigned int *)w_buf);

    // bitmap-disp-cntrler-axi-master　のアドレスを取得
    memset(buf, '\0', sizeof(buf)); // buf すべてに\0 を入れる
    // ls /sys/devices/axi.0 の内容をパイプに入れる
    fd = popen("ls /sys/devices/axi.0", "r");
    if (fd != NULL){
        read_num = fread(buf, sizeof(unsigned char), BUFSIZE, fd);
        if (read_num > 0){
            token = buf;
            if ((token=strtok(token, ".\n")) != NULL){
                do {
                    if (chkhex(token)){ // 16進数
                        sscanf(token, "%x", &val);
                    } else {
                        if (strcmp(token, "bitmap-disp-cntrler-axi-master") == 0)
                            bitmap_dc_reg_addr = val;
                    }
                }while((token=strtok(NULL, ".\n")) != NULL);
            }
        }
    }
    pclose(fd);

    // ラプラシアンフィルタの掛かった画像のスタートアドレスを bitmap-disp-cntrler-axi-master にセット
    bm_disp_cnt_reg = setup_io((off_t)bitmap_dc_reg_addr, &bitmap_buf);
    *bm_disp_cnt_reg = next_frame_addr;

    munmap((unsigned int *)bm_disp_cnt_reg, BLOCK_SIZE);
    free((unsigned int *)bitmap_buf);

    gettimeofday(&end_time, NULL);
    printf("rmmap_cnt = %d\n", rmmap_cnt);
    printf("wmmap_cnt = %d\n", wmmap_cnt);
    printf("total time = %d usec\n", end_time.tv_usec - start_time.tv_usec);
    return(0);
}


// RGBからYへの変換
// RGBのフォーマットは、{8'd0, R(8bits), G(8bits), B(8bits)}, 1pixel = 32bits
// 輝度信号Yのみに変換する。変換式は、Y =  0.299R + 0.587G + 0.114B
// "YUVフォーマット及び YUV<->RGB変換"を参考にした。http://vision.kuee.kyoto-u.ac.jp/~hiroaki/firewire/yuv.html
//
int conv_rgb2y(int rgb){
    float r, g, b, y_f;
    int y;

    b = (float)(rgb & 0xff);
    g = (float)((rgb>>8) & 0xff);
    r = (float)((rgb>>16) & 0xff);

    y_f = 0.299*r + 0.587*g + 0.114*b;
    y = (int)y_f;

    return(y);
}

// ラプラシアンフィルタ
// x0y0 x1y0 x2y0 -1 -1 -1
// x0y1 x1y1 x2y1 -1  8 -1
// x0y2 x1y2 x2y2 -1 -1 -1
int laplacian_fil(int x0y0, int x1y0, int x2y0, int x0y1, int x1y1, int x2y1, int x0y2, int x1y2, int x2y2)
{
     return(abs(-x0y0 -x1y0 -x2y0 -x0y1 +8*x1y1 -x2y1 -x0y2 -x1y2 -x2y2));
}

//
// Set up a memory regions to access GPIO
//
volatile unsigned *setup_io(off_t mapped_addr, unsigned int *buf_addr)
// void setup_io()
{
    int  mem_fd;
    char *gpio_mem, *gpio_map;

   /* open /dev/mem */
   if ((mem_fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0) {
      printf("can't open /dev/mem \n");
      printf("mapped_addr = %x\n", mapped_addr);
      exit (-1);
   }

   /* mmap GPIO */

   // Allocate MAP block
   if ((gpio_mem = malloc(BLOCK_SIZE + (PAGE_SIZE-1))) == NULL) {
      printf("allocation error \n");
      exit (-1);
   }
    *buf_addr = gpio_mem;    // mallocしたアドレスをコピー

   // Make sure pointer is on 4K boundary
   if ((unsigned long)gpio_mem % PAGE_SIZE)
     gpio_mem += PAGE_SIZE - ((unsigned long)gpio_mem % PAGE_SIZE);

   // Now map it
   gpio_map = (unsigned char *)mmap(
      (caddr_t)gpio_mem,
      BLOCK_SIZE,
      PROT_READ|PROT_WRITE,
      MAP_SHARED|MAP_FIXED,
      mem_fd,
      mapped_addr
   );

   if ((long)gpio_map < 0) {
      printf("mmap error %d\n", (int)gpio_map);
      printf("mapped_addr = %x\n", mapped_addr);
      exit (-1);
   }

   close(mem_fd); // /dev/mem のクローズ

   // Always use volatile pointer!
   // gpio = (volatile unsigned *)gpio_map;
   return((volatile unsigned *)gpio_map);

} // setup_io

// 文字列が16進数かを調べる
int chkhex(char *str){
    while (*str != '\0'){
        if (!isxdigit(*str))
            return 0;
        str++;
    }
    return 1;
}


前回、前々回、その１つ前の回とラプラシアン・フィルタのCソフトウェアの動作が不安定が事が多かった。そこで、フレーム・バッファのスタートアドレスがページ境界に合わせていないのが原因かもしれないと思い、Digilent Linux の起動時に、カメラ・コントローラやビットマップ・ディスプレイ・コントローラにフレーム・バッファの開始アドレスを指定する cam_disp3_linux.c プログラムを修正して、フレーム・バッファを4Kバイト境界から始まるように修正した。（修正した cam_disp3_linux.c のCソースコードについては、”ZedBoard Linux上でカメラの画像を処理する２（準備編２）”参照）

”ZedBoard Linux上でカメラの画像を処理する６（ラプラシアンフィルタ４）”と”ZedBoard Linux上でカメラの画像を処理する７（ラプラシアンフィルタ５）”のCソースコードもフレーム・バッファの開始アドレスが4kバイトのページ境界になるように修正を行った。

さて本題に入る。”ソフトウエアのプロファイリング１（mmap(), munmap() の時間計測）”で、”ZedBoard Linux上でカメラの画像を処理する７（ラプラシアンフィルタ５）”のCソースコード使用時の mmap() の呼び出し回数を計算したが、それをCソースコードにカウンタを用意して検算してみた。
af921a72.png


rmmap_cnt、wmmap_cntを用意して、mmap() を行った時に＋1してみた。それをプログラムの最後で次のように表示してみた。



	printf("rmmap_cnt = %d\n", rmmap_cnt);

	printf("wmmap_cnt = %d\n", wmmap_cnt);


結果を下に示す。

rmmap_cnt = 4294836
wmmap_cnt = 480000
total time = 138 sec


やはり、ピクセルのReadの方が10倍近く多い。4294836 + 480000 = 4774836（回）で前回の計算とぴったり一致した。

次に、”ZedBoard Linux上でカメラの画像を処理する６（ラプラシアンフィルタ４）”の方は、ReadとWriteの2つの mmap() 領域を用意して、それぞれ現在取得している領域が外れた時に munmap() して、もう一度領域を取り直す様になっている。こっちのほうが mmap() の実行回数が、前回プロファイリングしたCソースコードよりも少ないはずだ。それを計測してみた。更に、munmap() とそれに続く free() にの最初の1回の実行時間も計測した。下に結果を示す。

rmmap_cnt = 1223626
wmmap_cnt = 469
munmap() time = 36 usec
total time = 37 sec


Readによるmmap() の実行回数は、1223626 / 4294836 = 0.285倍になった。1/4 に近い数字だ。
Writeによるmmap() の実行回数は、469 / 480000 = 0.000977倍になった。1/1000 に近い数字だ。
Readはどうしても3ライン分を参照するので、ページ境界を超えてしまうので、どうしても mmap() する数が多くなるが、Writeはページ境界まで、無駄なくWriteできるので、劇的に mmap() する数が減っている。
munmap() とそれに続く free() に実行時間は、38usec という結果だった。これは少し大きすぎるように感じた。そこで、下図の様に、gettimeofday() の実行時間を計測してみたが、0usec だった。
3e392b5f.png


ここで2つの違ったCソースコードで計測できたので、mmap(), munmap() に掛かる時間を計算してみよう。
最初のCソースコードでは、4774836（回）のmmap(), munmap() を行い、全体の実行時間は 138秒だった。次のCソースコードでは、1224095（回）のmmap(), munmap() を行い、全体の実行時間は 37秒だった。これを使用して式を立てる。mmap(), munmap() 関連の実行時間を x として、それ以外の実行時間を y とすると、次の式が導ける。

4774836x + y = 138 ----- 式1
1224095x + y = 37 -----式2


式1と式2を解くと、x = 28.4 usec, y = 2.18 sec が導けた。
mmap(), munmap() 関連の実行時間が実測値と差がある。mmap(), munmap() 関連の実行時間以外の本来のラプラシアン・フィルタの実行時間は2秒程度だという結論に達した。

mmap(), munmap() 関連の実際の実行時間を測定してみた。10回測定すると平均が 62722 usec になってしまった。1回あたりの時間を取ってみた。

flag = 1, map_time = 626895
flag = 2, map_time = 55
flag = 3, map_time = 37
flag = 4, map_time = 37
flag = 5, map_time = 37
flag = 6, map_time = 37
flag = 7, map_time = 18
flag = 8, map_time = 37
flag = 9, map_time = 37
flag = 10, map_time = 37


最初が極端に長い。どうしてだろう？そのいうものなのか？ 630msec 程度もかかっている。（追記）下のプログラムだと、最初は、 gettimeofday(&temp1, NULL); が実行されずに、 gettimeofday(&temp2, NULL);を実行しちゃうからですね。最初を除いて正解でした。

最初を除いて、5000回の平均を取ってみた。

map time = 29 usec


大体、計算値と合った。
なお、総実行時間は 37秒で変化がなかった。gettimeofday() を入れたコストは少なかったようだ。（total time = 37 sec）

下に計測時のCソースコードを示す。

// laplacian_filter.c
// RGBをYに変換後にラプラシアンフィルタを掛ける。
// ピクセルのフォーマットは、{8'd0, R(8bits), G(8bits), B(8bits)}, 1pixel = 32bits
// 2013/09/16

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <dirent.h>
#include <fcntl.h>
#include <assert.h>
#include <ctype.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <linux/kernel.h>

#define HORIZONTAL_PIXEL_WIDTH    800
#define VERTICAL_PIXEL_WIDTH    600
#define ALL_PIXEL_VALUE    (HORIZONTAL_PIXEL_WIDTH*VERTICAL_PIXEL_WIDTH)

#define PAGE_SIZE (4*1024)
#define BLOCK_SIZE (4*1024)

#define BUFSIZE    1024

#define MEASURE_COUNT    5000

int laplacian_fil(int x0y0, int x1y0, int x2y0, int x0y1, int x1y1, int x2y1, int x0y2, int x1y2, int x2y2);
int conv_rgb2y(int rgb);
int chkhex(char *str);
volatile unsigned *setup_io(off_t mapped_addr, unsigned int *buf_addr);
void Xil_DCacheInvalidateLine(unsigned int adr);
void Xil_DCacheFlushLine(unsigned int adr);

int main()
{
    FILE *fd;
    int xy[3][3];
    char buf[BUFSIZE], *token;
    unsigned int read_num;
    unsigned int bitmap_dc_reg_addr;
    volatile unsigned *bm_disp_cnt_reg;
    unsigned int fb_addr, next_frame_addr;
    int x, y;
    unsigned int val;
    int i, j;
    int lap_fil_val;
    int *r_pixel, *w_pixel;
    unsigned int r_addr, w_addr;
    unsigned int r_addr_page, w_addr_page;
    unsigned int r_addr_page_pre=0, w_addr_page_pre=0;
    unsigned int r_addr_offset, w_addr_offset;
    unsigned int r_buf, w_buf, bitmap_buf;
    struct timeval start_time, temp1, temp2, end_time;
    unsigned int rmmap_cnt=0, wmmap_cnt=0;
    int flag=0;
    long map_time=0L;

    gettimeofday(&start_time, NULL);    // プログラム起動時の時刻を記録
    // fb_start_addr.txt の内容をパイプに入れる
    memset(buf, '\0', sizeof(buf)); // buf すべてに\0 を入れる
    // fb_start_addr.txt を開く
    fd = popen("cat /Apps/fb_start_addr.txt", "r");
    if (fd != NULL){
        read_num = fread(buf, sizeof(unsigned char), BUFSIZE, fd);
        if (read_num > 0){
            sscanf(buf, "%x\n", &fb_addr);
        }
    }
    pclose(fd);

    // ラプラシアンフィルタの結果を入れておくフレーム・バッファ
    next_frame_addr = ((fb_addr + (ALL_PIXEL_VALUE*4)) & (~(int)(PAGE_SIZE-1))) + PAGE_SIZE;

    // RGB値をY（輝度成分）のみに変換し、ラプラシアンフィルタを掛けた。
    for (y=0; y<VERTICAL_PIXEL_WIDTH; y++){
        for (x=0; x<HORIZONTAL_PIXEL_WIDTH; x++){
            if (y==0 || y==VERTICAL_PIXEL_WIDTH-1){ // 縦の境界の時の値は0とする
                lap_fil_val = 0;
            }else if (x==0 || x==HORIZONTAL_PIXEL_WIDTH-1){ // 横の境界の時も値は0とする
                lap_fil_val = 0;
            }else{
                for (j=-1; j<2; j++){
                    for (i=-1; i<2; i++){
                        r_addr = fb_addr+((y+j)*HORIZONTAL_PIXEL_WIDTH+(x+i))*4;
                        r_addr_page = r_addr & (~(int)(PAGE_SIZE-1));
                        r_addr_offset = r_addr & ((int)(PAGE_SIZE-1));
                        if (r_addr_page != r_addr_page_pre){    // 以前のページと違うのでunmmap してページの物理アドレスを取り直す
                           if (flag>1 && flag <= MEASURE_COUNT+1)
                                gettimeofday(&temp1, NULL);

                           if (r_addr_page_pre != 0){    // 初めの場合はmmap()していないので、munmap()しない
                                munmap(r_pixel, BLOCK_SIZE);
                                free((unsigned int *)r_buf);
                            }else{
                                flag++;
                            }

                            r_pixel = setup_io((off_t)r_addr_page, &r_buf);

                            if (flag>1 && flag <= MEASURE_COUNT+1){
                                gettimeofday(&temp2, NULL);
                                map_time = map_time + (temp2.tv_usec - temp1.tv_usec);
                                //printf("flag = %d, map_time = %d\n", flag, (temp2.tv_usec - temp1.tv_usec));
                                flag++;
                            }else{
                                flag++;
                            }

                            rmmap_cnt++;
                            r_addr_page_pre = r_addr_page;
                        }
                        xy[i+1][j+1] = *(volatile int *)((unsigned int)r_pixel + r_addr_offset);
                        xy[i+1][j+1] = conv_rgb2y(xy[i+1][j+1]);
                    }
                }
                lap_fil_val = laplacian_fil(xy[0][0], xy[1][0], xy[2][0], xy[0][1], xy[1][1], xy[2][1], xy[0][2], xy[1][2], xy[2][2]);
            }
            w_addr = next_frame_addr+(y*HORIZONTAL_PIXEL_WIDTH + x)*4;
            w_addr_page = w_addr & (~(int)(PAGE_SIZE-1));
            w_addr_offset = w_addr & ((int)(PAGE_SIZE-1));
            if (w_addr_page != w_addr_page_pre){    // 以前のページと違うのでunmmap してページの物理アドレスを取り直す
                if (w_addr_page_pre != 0){    // 初めの場合はmmap()していないので、munmap()しない
                    munmap(w_pixel, BLOCK_SIZE);
                    free((unsigned int *)w_buf);
                }
                w_pixel = setup_io((off_t)w_addr_page, &w_buf);
                wmmap_cnt++;
                w_addr_page_pre = w_addr_page;
            }
            *(volatile int *)((unsigned int)w_pixel + w_addr_offset) = (lap_fil_val<<16)+(lap_fil_val<<8)+lap_fil_val ;
            // printf("x = %d  y = %d", x, y);
        }
    }
    munmap((unsigned int *)r_addr_page, BLOCK_SIZE);
    free((unsigned int *)r_buf);
    munmap((unsigned int *)w_addr_page, BLOCK_SIZE);
    free((unsigned int *)w_buf);

    // bitmap-disp-cntrler-axi-master　のアドレスを取得
    memset(buf, '\0', sizeof(buf)); // buf すべてに\0 を入れる
    // ls /sys/devices/axi.0 の内容をパイプに入れる
    fd = popen("ls /sys/devices/axi.0", "r");
    if (fd != NULL){
        read_num = fread(buf, sizeof(unsigned char), BUFSIZE, fd);
        if (read_num > 0){
            token = buf;
            if ((token=strtok(token, ".\n")) != NULL){
                do {
                    if (chkhex(token)){ // 16進数
                        sscanf(token, "%x", &val);
                    } else {
                        if (strcmp(token, "bitmap-disp-cntrler-axi-master") == 0)
                            bitmap_dc_reg_addr = val;
                    }
                }while((token=strtok(NULL, ".\n")) != NULL);
            }
        }
    }
    pclose(fd);

    // ラプラシアンフィルタの掛かった画像のスタートアドレスを bitmap-disp-cntrler-axi-master にセット
    bm_disp_cnt_reg = setup_io((off_t)bitmap_dc_reg_addr, &bitmap_buf);
    *bm_disp_cnt_reg = next_frame_addr;

    munmap((unsigned int *)bm_disp_cnt_reg, BLOCK_SIZE);
    free((unsigned int *)bitmap_buf);

    gettimeofday(&end_time, NULL);
    printf("rmmap_cnt = %d\n", rmmap_cnt);
    printf("wmmap_cnt = %d\n", wmmap_cnt);
    printf("map time = %d usec\n", map_time/MEASURE_COUNT);
    printf("total time = %d sec\n", end_time.tv_sec - start_time.tv_sec);
    return(0);
}


// RGBからYへの変換
// RGBのフォーマットは、{8'd0, R(8bits), G(8bits), B(8bits)}, 1pixel = 32bits
// 輝度信号Yのみに変換する。変換式は、Y =  0.299R + 0.587G + 0.114B
// "YUVフォーマット及び YUV<->RGB変換"を参考にした。http://vision.kuee.kyoto-u.ac.jp/~hiroaki/firewire/yuv.html
//
int conv_rgb2y(int rgb){
    float r, g, b, y_f;
    int y;

    b = (float)(rgb & 0xff);
    g = (float)((rgb>>8) & 0xff);
    r = (float)((rgb>>16) & 0xff);

    y_f = 0.299*r + 0.587*g + 0.114*b;
    y = (int)y_f;

    return(y);
}

// ラプラシアンフィルタ
// x0y0 x1y0 x2y0 -1 -1 -1
// x0y1 x1y1 x2y1 -1  8 -1
// x0y2 x1y2 x2y2 -1 -1 -1
int laplacian_fil(int x0y0, int x1y0, int x2y0, int x0y1, int x1y1, int x2y1, int x0y2, int x1y2, int x2y2)
{
     return(abs(-x0y0 -x1y0 -x2y0 -x0y1 +8*x1y1 -x2y1 -x0y2 -x1y2 -x2y2));
}

//
// Set up a memory regions to access GPIO
//
volatile unsigned *setup_io(off_t mapped_addr, unsigned int *buf_addr)
// void setup_io()
{
    int  mem_fd;
    char *gpio_mem, *gpio_map;

   /* open /dev/mem */
   if ((mem_fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0) {
      printf("can't open /dev/mem \n");
      printf("mapped_addr = %x\n", mapped_addr);
      exit (-1);
   }

   /* mmap GPIO */

   // Allocate MAP block
   if ((gpio_mem = malloc(BLOCK_SIZE + (PAGE_SIZE-1))) == NULL) {
      printf("allocation error \n");
      exit (-1);
   }
    *buf_addr = gpio_mem;    // mallocしたアドレスをコピー

   // Make sure pointer is on 4K boundary
   if ((unsigned long)gpio_mem % PAGE_SIZE)
     gpio_mem += PAGE_SIZE - ((unsigned long)gpio_mem % PAGE_SIZE);

   // Now map it
   gpio_map = (unsigned char *)mmap(
      (caddr_t)gpio_mem,
      BLOCK_SIZE,
      PROT_READ|PROT_WRITE,
      MAP_SHARED|MAP_FIXED,
      mem_fd,
      mapped_addr
   );

   if ((long)gpio_map < 0) {
      printf("mmap error %d\n", (int)gpio_map);
      printf("mapped_addr = %x\n", mapped_addr);
      exit (-1);
   }

   close(mem_fd); // /dev/mem のクローズ

   // Always use volatile pointer!
   // gpio = (volatile unsigned *)gpio_map;
   return((volatile unsigned *)gpio_map);

} // setup_io

// 文字列が16進数かを調べる
int chkhex(char *str){
    while (*str != '\0'){
        if (!isxdigit(*str))
            return 0;
        str++;
    }
    return 1;
}


↑このページのトップヘ