Vector Optimized Library of Kernels  2.5.2
Architecture-tuned implementations of math kernels
volk_32f_8u_polarbutterflypuppet_32f.h
Go to the documentation of this file.
1 /* -*- c++ -*- */
2 /*
3  * Copyright 2015 Free Software Foundation, Inc.
4  *
5  * This file is part of VOLK
6  *
7  * SPDX-License-Identifier: GPL-3.0-or-later
8  */
9 
10 /*
11  * This puppet is for VOLK tests only.
12  * For documentation see 'kernels/volk/volk_32f_8u_polarbutterfly_32f.h'
13  */
14 
15 #ifndef VOLK_KERNELS_VOLK_VOLK_32F_8U_POLARBUTTERFLYPUPPET_32F_H_
16 #define VOLK_KERNELS_VOLK_VOLK_32F_8U_POLARBUTTERFLYPUPPET_32F_H_
17 
18 #include <volk/volk_32f_8u_polarbutterfly_32f.h>
19 #include <volk/volk_8u_x3_encodepolar_8u_x2.h>
20 #include <volk/volk_8u_x3_encodepolarpuppet_8u.h>
21 #include <volk/volk_8u_x2_encodeframepolar_8u.h>
22 
23 
24 static inline void sanitize_bytes(unsigned char* u, const int elements)
25 {
26  int i;
27  unsigned char* u_ptr = u;
28  for (i = 0; i < elements; i++) {
29  *u_ptr = (*u_ptr & 0x01);
30  u_ptr++;
31  }
32 }
33 
34 static inline void clean_up_intermediate_values(float* llrs,
35  unsigned char* u,
36  const int frame_size,
37  const int elements)
38 {
39  memset(u + frame_size, 0, sizeof(unsigned char) * (elements - frame_size));
40  memset(llrs + frame_size, 0, sizeof(float) * (elements - frame_size));
41 }
42 
43 static inline void
44 generate_error_free_input_vector(float* llrs, unsigned char* u, const int frame_size)
45 {
46  memset(u, 0, frame_size);
47  unsigned char* target = u + frame_size;
48  volk_8u_x2_encodeframepolar_8u_generic(target, u + 2 * frame_size, frame_size);
49  float* ft = llrs;
50  int i;
51  for (i = 0; i < frame_size; i++) {
52  *ft = (-2 * ((float)*target++)) + 1.0f;
53  ft++;
54  }
55 }
56 
57 static inline void
58 print_llr_tree(const float* llrs, const int frame_size, const int frame_exp)
59 {
60  int s, e;
61  for (s = 0; s < frame_size; s++) {
62  for (e = 0; e < frame_exp + 1; e++) {
63  printf("%+4.2f ", llrs[e * frame_size + s]);
64  }
65  printf("\n");
66  if ((s + 1) % 8 == 0) {
67  printf("\n");
68  }
69  }
70 }
71 
72 static inline int maximum_frame_size(const int elements)
73 {
74  unsigned int frame_size = next_lower_power_of_two(elements);
75  unsigned int frame_exp = log2_of_power_of_2(frame_size);
76  return next_lower_power_of_two(frame_size / frame_exp);
77 }
78 
79 #ifdef LV_HAVE_GENERIC
80 static inline void volk_32f_8u_polarbutterflypuppet_32f_generic(float* llrs,
81  const float* input,
82  unsigned char* u,
83  const int elements)
84 {
85  unsigned int frame_size = maximum_frame_size(elements);
86  unsigned int frame_exp = log2_of_power_of_2(frame_size);
87 
88  sanitize_bytes(u, elements);
89  clean_up_intermediate_values(llrs, u, frame_size, elements);
90  generate_error_free_input_vector(llrs + frame_exp * frame_size, u, frame_size);
91 
92  unsigned int u_num = 0;
93  for (; u_num < frame_size; u_num++) {
94  volk_32f_8u_polarbutterfly_32f_generic(llrs, u, frame_exp, 0, u_num, u_num);
95  u[u_num] = llrs[u_num] > 0 ? 0 : 1;
96  }
97 
98  clean_up_intermediate_values(llrs, u, frame_size, elements);
99 }
100 #endif /* LV_HAVE_GENERIC */
101 
102 #ifdef LV_HAVE_AVX
103 static inline void volk_32f_8u_polarbutterflypuppet_32f_u_avx(float* llrs,
104  const float* input,
105  unsigned char* u,
106  const int elements)
107 {
108  unsigned int frame_size = maximum_frame_size(elements);
109  unsigned int frame_exp = log2_of_power_of_2(frame_size);
110 
111  sanitize_bytes(u, elements);
112  clean_up_intermediate_values(llrs, u, frame_size, elements);
113  generate_error_free_input_vector(llrs + frame_exp * frame_size, u, frame_size);
114 
115  unsigned int u_num = 0;
116  for (; u_num < frame_size; u_num++) {
117  volk_32f_8u_polarbutterfly_32f_u_avx(llrs, u, frame_exp, 0, u_num, u_num);
118  u[u_num] = llrs[u_num] > 0 ? 0 : 1;
119  }
120 
121  clean_up_intermediate_values(llrs, u, frame_size, elements);
122 }
123 #endif /* LV_HAVE_AVX */
124 
125 #ifdef LV_HAVE_AVX2
126 static inline void volk_32f_8u_polarbutterflypuppet_32f_u_avx2(float* llrs,
127  const float* input,
128  unsigned char* u,
129  const int elements)
130 {
131  unsigned int frame_size = maximum_frame_size(elements);
132  unsigned int frame_exp = log2_of_power_of_2(frame_size);
133 
134  sanitize_bytes(u, elements);
135  clean_up_intermediate_values(llrs, u, frame_size, elements);
136  generate_error_free_input_vector(llrs + frame_exp * frame_size, u, frame_size);
137 
138  unsigned int u_num = 0;
139  for (; u_num < frame_size; u_num++) {
140  volk_32f_8u_polarbutterfly_32f_u_avx2(llrs, u, frame_exp, 0, u_num, u_num);
141  u[u_num] = llrs[u_num] > 0 ? 0 : 1;
142  }
143 
144  clean_up_intermediate_values(llrs, u, frame_size, elements);
145 }
146 #endif /* LV_HAVE_AVX2 */
147 
148 
149 #endif /* VOLK_KERNELS_VOLK_VOLK_32F_8U_POLARBUTTERFLYPUPPET_32F_H_ */