ZynqNet解析（三）CPU端程序解析

系统管理员 2022-05-13 11:26 224阅读 0赞

**背景：**ZynqNet能在xilinx的FPGA上实现deep compression的网络，

**目的：**读懂ZynqNetCPU端的代码。

**源码地址：**[https://github.com/dgschwend/zynqnet][https_github.com_dgschwend_zynqnet]

**目录**

cpu\_top

程序包括

1  CPU端创建网络

1.1 储存网络结构的结构体

1.2 创建网络的函数

1.3 输出每层信息

1.4 构造函数

2 FPGA端创建网络

2.1 axi-Lite通信

2.2 加载数据到DRAM

2.3 FPGA对DRAM的读取

3 控制FPGA运算

4 取回运算并输出结果

4.1 对比结果

--------------------

# cpu\_top #

\_HLS\_CODE中的cpu\_top程序为test Bench，用于测试HLS程序。

\_FIRMWARE中的cpu\_top为7z035的CPU代码。我们以此代码为目标。

# 程序包括 #

我们需要搞明白哪些是CPU端的函数，哪些是FPGA端的用于HLS编译的函数。

*  cpu\_top用于运行的最高层级的函数
 *  axilite运用进行AXIlite通信的底层函数，驱动，写入与读取等等。与xfpga配合
 *  xfpga与axilite配合，将相应的数据进行axilite协议进行通信写入FPGA
 *  netconfig定义存储层和神经网络的结构体信息，以及创建网络相关的函数，如addlayer函数
 *  network定义网络结构和相应参数的函数
 *  shared\_dram在hpp中定义DRAM上的地址位值，然后在cpp之中实现相应的函数。

# 1  CPU端创建网络 #

CPU端的网络信息

//cpu_top  main   
    // = Setup Network on CPU =
      // Generate + Load Network Config from network.hpp/network.cpp
      network_t *net_CPU = get_network_config();
      printf("\nCPU: Load Network Configuration\n");
      print_layers(net_CPU);
      printf("\n");

## 1.1 储存网络结构的结构体 ##

创建network\_t的结构体指针，\*net\_CPU;这个为网络在CPU端的指针，里面存储着网络的信息。

**network\_t与layer\_t**为结构体，均在netconfig.hpp中定义。其中储存神经网络的信息。以后CPU所有关于神经网络的信息都在这两个结构体中调用。

## 1.2 创建网络的函数 ##

network\_t \*net\_CPU = get\_network\_config();这个函数在network.cpp中，一层一层用addLayer函数加入每层layer的信息,然后用loadWeightsFromFile加载权重信息。

// network.c
    network_t *get_network_config() {
      network_t *net = new network_t(27, 2528800);
    
      // Layer Attributes: ( NAME   ,   W,   H,   CI,  CO, K, P, S, R, S1, S2, GP)
      addLayer(net, layer_t("c1    ", 256, 256,    3,  64, 3, 1, 2, 1,  0,  0,  0));
      addLayer(net, layer_t("f2/s3 ", 128, 128,   64,  16, 3, 1, 2, 1,  0,  0,  0));
      addLayer(net, layer_t("f2/e1 ",  64,  64,   16,  64, 1, 0, 1, 1,  1,  0,  0));
    ...
      net->num_weights = 2528800;
      const char* filename = "weights.bin";
      loadWeightsFromFile(net, filename);
      return net;
    }

**addLayer**函数在netconfig.cpp中。从前往后参数分别为name，weight，hight，channel in，channel out，kernel，pad，ReLU，spilt1，spilt2，global pooling

**loadWeightsFromFile**函数也在netconfig.cpp中，函数用于一层一层的加载权重。

## 1.3 输出每层信息 ##

print\_layers(net\_CPU)函数用于输出每层网络的信息，其中子函数为print\_layer。在netconfig.cpp中

## 1.4 构造函数 ##

我们注意到，在结构体之中，有一个比较新的语句方式。

struct layer_t {
      char name[NET_NAME_MAX_LEN + 1];
      dimension_t width;  // input dimensions
      dimension_t height;
      channel_t channels_in;
      channel_t channels_out;
      kernel_t kernel;  // kernel sizes supported: 3 or 1
      stride_t stride;  // only stride 1 or 2 supported
      bool pad;         // padding is either 0 or 1 pixel
      bool relu;
      bool is_first_split_layer;
      bool is_second_split_layer;
      bool global_pool;
      memaddr_t mem_addr_input;
      memaddr_t mem_addr_output;
      memaddr_t mem_addr_weights;
      // full constructor, used to define network in network.cpp
      layer_t(const char *n, int w, int h, int ci, int co, int k, int p, int s,
              int r, bool is_split_1 = false, bool is_split_2 = false,
              bool global_pool = false, int mem_i = 0, int mem_o = 0, int mem_w = 0)
          : width(w),
            height(h),
            channels_in(ci),
            channels_out(co),
            kernel(k),
            pad(p),
            stride(s),
            relu(r),
            mem_addr_input(mem_i),
            mem_addr_output(mem_o),
            mem_addr_weights(mem_w),
            is_first_split_layer(is_split_1),
            is_second_split_layer(is_split_2),
            global_pool(global_pool) {
        for (int i = 0; i < NET_NAME_MAX_LEN; i++) {
          name[i] = n[i];
          if (n[i] == 0) break;
        }
        name[NET_NAME_MAX_LEN] = 0;
      };
      // empty constructor, needed for empty array of layer_t in FPGA BRAM
      layer_t()
          : width(0),
            height(0),
            channels_in(0),
            channels_out(0),
            kernel(0),
            pad(0),
            stride(0),
            relu(0),
            mem_addr_input(0),
            mem_addr_output(0),
            mem_addr_weights(0),
            is_first_split_layer(0),
            is_second_split_layer(0),
            global_pool(0) {
        name[0] = 0;
      };
    };

原程序之中，下面两个layer\_t就是构造函数。一个为全构造函数，一个为缺省构造函数，

[https://blog.csdn.net/alex1997222/article/details/81219663?utm\_source=blogxgwz0][https_blog.csdn.net_alex1997222_article_details_81219663_utm_source_blogxgwz0]

[相关内容，类的构造函数与析构函数 http://www.runoob.com/cplusplus/cpp-constructor-destructor.html][http_www.runoob.com_cplusplus_cpp-constructor-destructor.html]

//network.cpp  in network_t *get_network_config() funciton
    network_t *get_network_config() {
      network_t *net = new network_t(27, 2528800);
    
      // Layer Attributes: ( NAME   ,   W,   H,   CI,  CO, K, P, S, R, S1, S2, GP)
      addLayer(net, layer_t("c1    ", 256, 256,    3,  64, 3, 1, 2, 1,  0,  0,  0));
      addLayer(net, layer_t("f2/s3 ", 128, 128,   64,  16, 3, 1, 2, 1,  0,  0,  0));
    。。。

后面的layer\_t即为全构造函数。先根据构造函数构造相应的layer，然后运用addLayer函数赋值给net

// in addLayer funciton   netconfig.cpp
      // Add Layer to network
      net->layers[net->num_layers] = layer;
      net->num_layers++;
      net->total_pixel_mem = current_output_addr + output_data_pixels;

# 2 FPGA端创建网络 #

相当于用单片机分配DRAM上的地址传输给FPGA

## 2.1 axi-Lite通信 ##

// main
      // Initialize AXILITE Configuration Bus + Shared DRAM region
      if (USE_FPGA_BLOCK) XFPGA_Initialize();

初始化AXI-Lite通信，驱动程序是自动生成的，IPcore的相关驱动程序在xfpga.cpp中

后面用XFPGA\_set...来进行相应的值的设置。

## 2.2 加载数据到DRAM ##

//main
      // Allocate Shared Memory in DRAM for Weights + Data.
      allocate_DRAM_memory(net_CPU);
    
      // Copy Layer Weights to DRAM.
      copy_weights_to_DRAM(net_CPU);
    
      // ===========================
      // = Load + Copy Input Image =
      // ===========================
      layer_t input_layer = net_CPU->layers[0];
      // Allocate Memory for Input Image:
      data_t *input_image = allocate_image_memory(input_layer);
      // Load Input Image
      load_prepared_input_image(input_layer, input_image, input_filename);
      // Copy Input Image into shared DRAM
      copy_input_image_to_DRAM(input_layer, input_image);

这几个函数均在cpu\_top.cpp中，

allocate\_DRAM\_memory(net\_CPU);根据分配DRAM的地址，copy\_weights\_to\_DRAM将net\_CPU->weights中的权重读到DRAM中。注意，weights也是先从文件读到buffer，然后再由buffer读到DRAM之中的。**loadWeightsFromFile见1.1.2**

load\_prepared\_input\_image和copy\_input\_image\_to\_DRAM分别是将图像的数据从file存到buffer和从buffer读到DRAM之中。

## 2.3 FPGA对DRAM的读取 ##

//cpu_top.cpp  in function  allocate_DRAM_memory
      // Memory Allocation
      if (USE_FPGA_BLOCK) {
        // Get Pointer to SHARED DRAM from XFPGA wrapper
        SHARED_DRAM = (volatile char *)XFPGA_shared_DRAM_virtual();
      } else {
        // Allocate SHARED DRAM on Heap
        SHARED_DRAM = (volatile char *)malloc(total_size);
      }

其中XFPGA\_shared\_DRAM\_virtual是xfpga.cpp中的程序， SHARED\_DRAM =  (volatile char \* ) XFPGA\_shared\_DRAM\_virtual ();返回 SHARED\_DRAM 指针。

allocate\_DRAM\_memory函数就是根据网络的信息分配出DRAM上的地址。指针信息存在SHARED\_DRAM， SHARED\_DRAM\_WEIGHTS， 和SHARED\_DRAM\_DATA中这三个变量是在main函数之外定义的volatile data\_t型的变量，可以看作全局变量。

# 3 控制FPGA运算 #

两次for循环控制相应的迭代与层数，其内用axi-Lite通信给FPGA传输数据控制FPGA进行运算。

// main  for iteration  for num_layers
        if (USE_FPGA_BLOCK) {
          // FPGA Accelerator Block
          XFPGA_setLayerConfig(layer);
          XFPGA_Start();
          while (!XFPGA_IsDone()) { // busy-wait
            usleep(1);            // sleep 100us
            if (!BE_QUIET)
              LOG("XFPGA Status: Done = %d, Idle = %d, Ready = %d\n", XFPGA_IsDone(),
                  XFPGA_IsIdle(), XFPGA_IsReady());
          }
        } else {  
          // CPU Simulation
          // Precalculate some Layer Parameters on CPU
          numfilterelems_t w_per_f = (layer.kernel == 3) ? 9 : 1;
          weightaddr_t n_weights = layer.channels_in * layer.channels_out * w_per_f;
          fpga_top(layer, (data_t *)SHARED_DRAM, weights_offset, n_weights,
                   input_offset);
        }

其中，XFPGA\_setLayerConfig(layer);函数将每层layer的信息传输给FPGA，然后运用FPGA运算。该函数也在xfpga.cpp中

# 4 取回运算并输出结果 #

// Fetch Results from FPGA
      data_t *results = (data_t *)malloc(ch_out * sizeof(data_t));
      copy_results_from_DRAM(results, ch_out);
    
      // = Release FPGA core =
      if (USE_FPGA_BLOCK) XFPGA_Release();
    
      // = Calculate Softmax =
      std::vector<std::pair<data_t, int> > probabilities(ch_out);
      calculate_softmax(net_CPU, results, probabilities);

运用  copy\_results\_from\_DRAM(results, ch\_out); 从DRAM上读回数据，然后运用softmax预测概率。

## 4.1 对比结果 ##

// main 
     // Check if output is AS EXPECTED (+- 0.5%) (defined in network.hpp)
      if (fabs(100 * probabilities[0].first - TEST_RESULT_EXPECTED) < 0.1) {
        printf("\nTestBench Result: SUCCESS\n");
        return 0;
      } else {
        printf("\nTestBench Result: FAILURE\n");
        printf("Actual: %5.2f, Expected: %5.2f\n", 100 * probabilities[0].first,
               TEST_RESULT_EXPECTED);
        return -1;
      }

输出结果在TEST\_RESULT\_EXPECTED进行对比，其定义在network.hpp之中，运用const float定义的全局变量。

[https_github.com_dgschwend_zynqnet]: https://github.com/dgschwend/zynqnet
[https_blog.csdn.net_alex1997222_article_details_81219663_utm_source_blogxgwz0]: https://blog.csdn.net/alex1997222/article/details/81219663?utm_source=blogxgwz0
[http_www.runoob.com_cplusplus_cpp-constructor-destructor.html]: http://www.runoob.com/cplusplus/cpp-constructor-destructor.html