gr cpu指令加速库volk使用复数数组相乘

东方耀

gr cpu指令加速库volk使用复数数组相乘

1. #include <iostream>
   
2. #include <volk/volk.h>
   
3. #include <complex>
   
4. #include <vector>
   
5. 
   
6. using namespace std;
   
7. 
   
8. typedef std::complex<float> gr_complex;   //这个float精度与fftwf一致
   
9. 
   
10. void print_vector_complex(std::vector<gr_complex>& v){
    
11.     for(std::vector<gr_complex>::iterator it=v.begin();it!=v.end();it++){
    
12.         cout << "value of complex: real=" << (*it).real() << ",imag=" << (*it).imag() << endl;
    
13.     }
    
14. 
    
15. }
    
16. 
    
17. void main_gr(){
    
18.     int noutput_items = 10;
    
19.     std::vector<gr_complex> d_hold_in;   //这是容器对象 vector动态数组
    
20.     std::vector<gr_complex> d_filt_doppler;
    
21.     gr_complex in[noutput_items];  // int a[10]; in是数组名
    
22. 
    
23.     cout << "容器的大小=" << d_hold_in.size() << endl;
    
24.     d_hold_in.resize(noutput_items);
    
25.     d_filt_doppler.resize(noutput_items);
    
26.     cout << "容器的大小=" << d_hold_in.size() << endl;
    
27. 
    
28. 
    
29.     // 输入的数据  赋值
    
30.     for(int i=0;i<noutput_items; i++){
    
31.         //d_hold_in.push_back(gr_complex(i, 0));
    
32.         //d_hold_in[i] = gr_complex(i,i+10);
    
33.         d_filt_doppler[i] = gr_complex(i, i);
    
34.         in[i] = gr_complex(i+5,i);
    
35.     }
    
36. 
    
37.     int array_len = sizeof(in) / sizeof(gr_complex);
    
38. 
    
39.     //cout << "输入数据赋初值d_hold_in:" << endl;
    
40.     //print_vector_complex(d_hold_in);
    
41.    
    
42.    
    
43.     cout << "看看数组in的值:len=" << array_len << endl;
    
44.     for(int i=0;i<array_len;i++){
    
45.         cout << i << "个数组元素: real=" << in[i].real() << ",imag=" << in[i].imag() << endl;
    
46.     }
    
47. 
    
48.     cout << "输入数据赋初值d_filt_doppler:" << endl;
    
49.     print_vector_complex(d_filt_doppler);
    
50. 
    
51.     //target_link_libraries(main -lvolk)
    
52.     //typedef std::complex<float>   lv_32fc_t;  只能是复数
    
53.     //参数类型(lv_32fc_t *, const lv_32fc_t *, const lv_32fc_t *, unsigned int)
    
54.     // 函数作用：复数数组与复数数组相乘 就是对应元素复数相乘的结果
    
55.     volk_32fc_x2_multiply_32fc(
    
56.                 &d_hold_in[0],  //容器对象首元素的地址   只有这个变了  *out
    
57.                 in,  // 数组名 就是入口地址   没变    *in1
    
58.                 &d_filt_doppler[0],   //  没变     *in2
    
59.                 noutput_items);
    
60. 
    
61.     cout << "经过volk_32fc_x2_multiply_32fc函数之后【in1*in2=out】：" << endl;
    
62. 
    
63.     cout << "d_hold_in【只有这个变了】:" << endl;
    
64.     print_vector_complex(d_hold_in);
    
65. 
    
66.     // for(int i=0;i<array_len;i++){
    
67.     //     cout << i << "个数组元素【不变】: real=" << in[i].real() << ",imag=" << in[i].imag() << endl;
    
68.     // }
    
69. 
    
70.     // cout << "d_filt_doppler【没有变】:" << endl;
    
71.     // print_vector_complex(d_filt_doppler);
    
72. 
    
73. 
    
74. }
    
75. 
    
76. 
    
77. void main_jjj(){
    
78.     int noutput_items = 10;
    
79.     std::vector<gr_complex> out;   //这是容器对象 vector动态数组
    
80.     std::vector<gr_complex> in_1;
    
81.     std::vector<gr_complex> in_2;
    
82. 
    
83.     out.resize(noutput_items);
    
84.     in_1.resize(noutput_items);  // 这样就不能.push_back()了
    
85.     in_2.resize(noutput_items);
    
86. 
    
87. 
    
88.     // 输入的数据  赋值
    
89.     for(int i=0;i<noutput_items; i++){
    
90.         //d_hold_in.push_back(gr_complex(i, 0));
    
91.         //d_hold_in[i] = gr_complex(i,i+10);
    
92.         in_1[i] = gr_complex(i, i);
    
93.         in_2[i] = gr_complex(i+5, i);
    
94.     }
    
95. 
    
96. 
    
97.     cout << "输入数据赋初值in_1:" << endl;
    
98.     print_vector_complex(in_1);
    
99. 
    
100.     cout << "输入数据赋初值in_2:" << endl;
     
101.     print_vector_complex(in_2);
     
102. 
     
103. 
     
104.     //target_link_libraries(main -lvolk)
     
105.     //typedef std::complex<float>   lv_32fc_t;  只能是复数
     
106.     //参数类型(lv_32fc_t *, const lv_32fc_t *, const lv_32fc_t *, unsigned int)
     
107.     // 函数作用：复数数组与复数数组相乘 就是对应元素复数相乘的结果  这个可能优化了
     
108.     volk_32fc_x2_multiply_32fc(
     
109.                 &out[0],  //容器对象首元素的地址   只有这个变了  *out
     
110.                 &in_1[0],  //     *in1
     
111.                 &in_2[0],   //  没变     *in2
     
112.                 noutput_items);
     
113. 
     
114.     cout << "经过volk_32fc_x2_multiply_32fc函数之后【in1*in2=out】：" << endl;
     
115. 
     
116.     cout << "输出结果out【只有这个变了】:" << endl;
     
117.     print_vector_complex(out);
     
118. 
     
119. 
     
120. }
     
121. 
     
122. //gr cpu指令加速库volk使用复数数组相乘
     
123. 
     
124. int main(){
     
125.     // main_gr();    // 模仿gr的写法
     
126.     main_jjj();    //自己改成 好理解
     
127.     return 0;
     
128. }
     
129. 
     
130. 
     

复制代码