Barretenberg
The ZK-SNARK library at the core of Aztec
Loading...
Searching...
No Matches
bitwise_trace.test.cpp
Go to the documentation of this file.
1#include <gmock/gmock.h>
2#include <gtest/gtest.h>
3
4#include <cstdint>
5
6#include "barretenberg/vm2/common/memory_types.hpp"
7#include "barretenberg/vm2/testing/macros.hpp"
8#include "barretenberg/vm2/tracegen/bitwise_trace.hpp"
9#include "barretenberg/vm2/tracegen/test_trace_container.hpp"
10
11namespace bb::avm2::tracegen {
12namespace {
13
14using testing::ElementsAre;
15
16TEST(BitwiseTraceGenTest, U1And)
17{
18 TestTraceContainer trace;
19 BitwiseTraceBuilder builder;
20
21 builder.process(
22 {
23 {
24 .operation = BitwiseOperation::AND,
25 .a = MemoryValue::from(uint1_t(0)),
26 .b = MemoryValue::from(uint1_t(1)),
27 .res = 0,
28 },
29 },
30 trace);
31
32 EXPECT_EQ(trace.as_rows().size(), 2);
33
34 EXPECT_THAT(trace.as_rows(),
35 ElementsAre(AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
36 ROW_FIELD_EQ(bitwise_acc_ia, 0),
37 ROW_FIELD_EQ(bitwise_acc_ib, 0),
38 ROW_FIELD_EQ(bitwise_acc_ic, 0),
39 ROW_FIELD_EQ(bitwise_ia_byte, 0),
40 ROW_FIELD_EQ(bitwise_ib_byte, 0),
41 ROW_FIELD_EQ(bitwise_ic_byte, 0),
42 ROW_FIELD_EQ(bitwise_ctr, 0),
43 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
44 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
45 ROW_FIELD_EQ(bitwise_last, 1),
46 ROW_FIELD_EQ(bitwise_sel, 0),
47 ROW_FIELD_EQ(bitwise_start, 0)),
48 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
49 ROW_FIELD_EQ(bitwise_acc_ia, 0),
50 ROW_FIELD_EQ(bitwise_acc_ib, 1),
51 ROW_FIELD_EQ(bitwise_acc_ic, 0),
52 ROW_FIELD_EQ(bitwise_ia_byte, 0),
53 ROW_FIELD_EQ(bitwise_ib_byte, 1),
54 ROW_FIELD_EQ(bitwise_ic_byte, 0),
55 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(MemoryTag::U1)),
56 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(MemoryTag::U1)),
57 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(MemoryTag::U1)),
58 ROW_FIELD_EQ(bitwise_ctr, 1),
59 ROW_FIELD_EQ(bitwise_ctr_inv, 1),
60 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
61 ROW_FIELD_EQ(bitwise_last, 1),
62 ROW_FIELD_EQ(bitwise_sel, 1),
63 ROW_FIELD_EQ(bitwise_sel_get_ctr, 1),
64 ROW_FIELD_EQ(bitwise_start, 1))));
65}
66
67TEST(BitwiseTraceGenTest, U32And)
68{
69 TestTraceContainer trace;
70 BitwiseTraceBuilder builder;
71
72 builder.process(
73 {
74 {
75 .operation = BitwiseOperation::AND,
76 .a = MemoryValue::from<uint32_t>(0x52488425),
77 .b = MemoryValue::from<uint32_t>(0xC684486C),
78 .res = 0x42000024,
79 },
80 },
81 trace);
82
83 EXPECT_EQ(trace.as_rows().size(), 5);
84
85 EXPECT_THAT(trace.as_rows(),
86 ElementsAre(AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
87 ROW_FIELD_EQ(bitwise_acc_ia, 0),
88 ROW_FIELD_EQ(bitwise_acc_ib, 0),
89 ROW_FIELD_EQ(bitwise_acc_ic, 0),
90 ROW_FIELD_EQ(bitwise_ia_byte, 0),
91 ROW_FIELD_EQ(bitwise_ib_byte, 0),
92 ROW_FIELD_EQ(bitwise_ic_byte, 0),
93 ROW_FIELD_EQ(bitwise_ctr, 0),
94 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
95 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
96 ROW_FIELD_EQ(bitwise_last, 1),
97 ROW_FIELD_EQ(bitwise_sel, 0),
98 ROW_FIELD_EQ(bitwise_start, 0)),
99 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
100 ROW_FIELD_EQ(bitwise_acc_ia, 0x52488425),
101 ROW_FIELD_EQ(bitwise_acc_ib, 0xC684486C),
102 ROW_FIELD_EQ(bitwise_acc_ic, 0x42000024),
103 ROW_FIELD_EQ(bitwise_ia_byte, 0x25),
104 ROW_FIELD_EQ(bitwise_ib_byte, 0x6C),
105 ROW_FIELD_EQ(bitwise_ic_byte, 0x24),
106 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(MemoryTag::U32)),
107 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(MemoryTag::U32)),
108 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(MemoryTag::U32)),
109 ROW_FIELD_EQ(bitwise_ctr, 4),
110 ROW_FIELD_EQ(bitwise_ctr_inv, FF(4).invert()),
111 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, FF(3).invert()),
112 ROW_FIELD_EQ(bitwise_last, 0),
113 ROW_FIELD_EQ(bitwise_sel, 1),
114 ROW_FIELD_EQ(bitwise_sel_get_ctr, 1),
115 ROW_FIELD_EQ(bitwise_start, 1)),
116 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
117 ROW_FIELD_EQ(bitwise_acc_ia, 0x524884),
118 ROW_FIELD_EQ(bitwise_acc_ib, 0xC68448),
119 ROW_FIELD_EQ(bitwise_acc_ic, 0x420000),
120 ROW_FIELD_EQ(bitwise_ia_byte, 0x84),
121 ROW_FIELD_EQ(bitwise_ib_byte, 0x48),
122 ROW_FIELD_EQ(bitwise_ic_byte, 0x00),
123 ROW_FIELD_EQ(bitwise_tag_a, 0),
124 ROW_FIELD_EQ(bitwise_tag_b, 0),
125 ROW_FIELD_EQ(bitwise_tag_c, 0),
126 ROW_FIELD_EQ(bitwise_ctr, 3),
127 ROW_FIELD_EQ(bitwise_ctr_inv, FF(3).invert()),
128 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, FF(2).invert()),
129 ROW_FIELD_EQ(bitwise_last, 0),
130 ROW_FIELD_EQ(bitwise_sel, 1),
131 ROW_FIELD_EQ(bitwise_start, 0)),
132 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
133 ROW_FIELD_EQ(bitwise_acc_ia, 0x5248),
134 ROW_FIELD_EQ(bitwise_acc_ib, 0xC684),
135 ROW_FIELD_EQ(bitwise_acc_ic, 0x4200),
136 ROW_FIELD_EQ(bitwise_ia_byte, 0x48),
137 ROW_FIELD_EQ(bitwise_ib_byte, 0x84),
138 ROW_FIELD_EQ(bitwise_ic_byte, 0x00),
139 ROW_FIELD_EQ(bitwise_tag_a, 0),
140 ROW_FIELD_EQ(bitwise_tag_b, 0),
141 ROW_FIELD_EQ(bitwise_tag_c, 0),
142 ROW_FIELD_EQ(bitwise_ctr, 2),
143 ROW_FIELD_EQ(bitwise_ctr_inv, FF(2).invert()),
144 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 1),
145 ROW_FIELD_EQ(bitwise_last, 0),
146 ROW_FIELD_EQ(bitwise_sel, 1),
147 ROW_FIELD_EQ(bitwise_start, 0)),
148 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
149 ROW_FIELD_EQ(bitwise_acc_ia, 0x52),
150 ROW_FIELD_EQ(bitwise_acc_ib, 0xC6),
151 ROW_FIELD_EQ(bitwise_acc_ic, 0x42),
152 ROW_FIELD_EQ(bitwise_ia_byte, 0x52),
153 ROW_FIELD_EQ(bitwise_ib_byte, 0xC6),
154 ROW_FIELD_EQ(bitwise_ic_byte, 0x42),
155 ROW_FIELD_EQ(bitwise_tag_a, 0),
156 ROW_FIELD_EQ(bitwise_tag_b, 0),
157 ROW_FIELD_EQ(bitwise_tag_c, 0),
158 ROW_FIELD_EQ(bitwise_ctr, 1),
159 ROW_FIELD_EQ(bitwise_ctr_inv, 1),
160 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
161 ROW_FIELD_EQ(bitwise_last, 1),
162 ROW_FIELD_EQ(bitwise_sel, 1),
163 ROW_FIELD_EQ(bitwise_start, 0))));
164}
165
166TEST(BitwiseTraceGenTest, ErrorInputFF)
167{
168 TestTraceContainer trace;
169 BitwiseTraceBuilder builder;
170
171 std::vector<simulation::BitwiseEvent> events = {
172 { .operation = BitwiseOperation::AND,
173 .a = MemoryValue::from_tag(MemoryTag::FF, 1),
174 .b = MemoryValue::from_tag(MemoryTag::FF, 1),
175 .res = 0 },
176 };
177 builder.process(events, trace);
178
179 EXPECT_THAT(trace.as_rows(),
180 ElementsAre(AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
181 ROW_FIELD_EQ(bitwise_acc_ia, 0),
182 ROW_FIELD_EQ(bitwise_acc_ib, 0),
183 ROW_FIELD_EQ(bitwise_acc_ic, 0),
184 ROW_FIELD_EQ(bitwise_ia_byte, 0),
185 ROW_FIELD_EQ(bitwise_ib_byte, 0),
186 ROW_FIELD_EQ(bitwise_ic_byte, 0),
187 ROW_FIELD_EQ(bitwise_ctr, 0),
188 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
189 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
190 ROW_FIELD_EQ(bitwise_last, 1),
191 ROW_FIELD_EQ(bitwise_sel, 0)),
192 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
193 ROW_FIELD_EQ(bitwise_acc_ia, 1),
194 ROW_FIELD_EQ(bitwise_acc_ib, 1),
195 ROW_FIELD_EQ(bitwise_acc_ic, 0),
196 ROW_FIELD_EQ(bitwise_ia_byte, 1),
197 ROW_FIELD_EQ(bitwise_ib_byte, 1),
198 ROW_FIELD_EQ(bitwise_ic_byte, 0),
199 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(MemoryTag::FF)),
200 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(MemoryTag::FF)),
201 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(MemoryTag::FF)),
202 ROW_FIELD_EQ(bitwise_ctr, 0),
203 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
204 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
205 ROW_FIELD_EQ(bitwise_last, 1),
206 // Err Flags
207 ROW_FIELD_EQ(bitwise_sel_tag_ff_err, 1),
208 ROW_FIELD_EQ(bitwise_sel_tag_mismatch_err, 0),
209 ROW_FIELD_EQ(bitwise_err, 1),
210 ROW_FIELD_EQ(bitwise_tag_a_inv, 0))));
211}
212
213TEST(BitwiseTraceGenTest, ErrorTagMismatch)
214{
215 TestTraceContainer trace;
216 BitwiseTraceBuilder builder;
217
218 std::vector<simulation::BitwiseEvent> events = {
219 { .operation = BitwiseOperation::AND,
220 .a = MemoryValue::from_tag(MemoryTag::U8, 1),
221 .b = MemoryValue::from_tag(MemoryTag::U16, 1),
222 .res = 0 },
223 };
224 builder.process(events, trace);
225
226 EXPECT_THAT(
227 trace.as_rows(),
228 ElementsAre(
229 AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
230 ROW_FIELD_EQ(bitwise_acc_ia, 0),
231 ROW_FIELD_EQ(bitwise_acc_ib, 0),
232 ROW_FIELD_EQ(bitwise_acc_ic, 0),
233 ROW_FIELD_EQ(bitwise_ia_byte, 0),
234 ROW_FIELD_EQ(bitwise_ib_byte, 0),
235 ROW_FIELD_EQ(bitwise_ic_byte, 0),
236 ROW_FIELD_EQ(bitwise_ctr, 0),
237 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
238 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
239 ROW_FIELD_EQ(bitwise_last, 1),
240 ROW_FIELD_EQ(bitwise_sel, 0)),
241 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
242 ROW_FIELD_EQ(bitwise_acc_ia, 1),
243 ROW_FIELD_EQ(bitwise_acc_ib, 1),
244 ROW_FIELD_EQ(bitwise_acc_ic, 0),
245 ROW_FIELD_EQ(bitwise_ia_byte, 1),
246 ROW_FIELD_EQ(bitwise_ib_byte, 1),
247 ROW_FIELD_EQ(bitwise_ic_byte, 0),
248 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(MemoryTag::U8)),
249 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(MemoryTag::U16)),
250 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(MemoryTag::FF)),
251 ROW_FIELD_EQ(bitwise_ctr, 0),
252 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
253 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
254 ROW_FIELD_EQ(bitwise_last, 1),
255 // Err Flags
256 ROW_FIELD_EQ(bitwise_sel_tag_ff_err, 0),
257 ROW_FIELD_EQ(bitwise_sel_tag_mismatch_err, 1),
258 ROW_FIELD_EQ(bitwise_err, 1),
259 ROW_FIELD_EQ(
260 bitwise_tag_ab_diff_inv,
261 FF(static_cast<uint8_t>(MemoryTag::U8) - static_cast<uint8_t>(MemoryTag::U16)).invert()))));
262}
263
264TEST(BitwiseTraceGenTest, ErrorFFAndTagMismatch)
265{
266 TestTraceContainer trace;
267 BitwiseTraceBuilder builder;
268
269 std::vector<simulation::BitwiseEvent> events = {
270 { .operation = BitwiseOperation::AND,
271 .a = MemoryValue::from_tag(MemoryTag::FF, 1),
272 .b = MemoryValue::from_tag(MemoryTag::U16, 1),
273 .res = 0 },
274 };
275 builder.process(events, trace);
276
277 EXPECT_THAT(
278 trace.as_rows(),
279 ElementsAre(
280 AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
281 ROW_FIELD_EQ(bitwise_acc_ia, 0),
282 ROW_FIELD_EQ(bitwise_acc_ib, 0),
283 ROW_FIELD_EQ(bitwise_acc_ic, 0),
284 ROW_FIELD_EQ(bitwise_ia_byte, 0),
285 ROW_FIELD_EQ(bitwise_ib_byte, 0),
286 ROW_FIELD_EQ(bitwise_ic_byte, 0),
287 ROW_FIELD_EQ(bitwise_ctr, 0),
288 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
289 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
290 ROW_FIELD_EQ(bitwise_last, 1),
291 ROW_FIELD_EQ(bitwise_sel, 0)),
292 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
293 ROW_FIELD_EQ(bitwise_acc_ia, 1),
294 ROW_FIELD_EQ(bitwise_acc_ib, 1),
295 ROW_FIELD_EQ(bitwise_acc_ic, 0),
296 ROW_FIELD_EQ(bitwise_ia_byte, 1),
297 ROW_FIELD_EQ(bitwise_ib_byte, 1),
298 ROW_FIELD_EQ(bitwise_ic_byte, 0),
299 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(MemoryTag::FF)),
300 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(MemoryTag::U16)),
301 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(MemoryTag::FF)),
302 ROW_FIELD_EQ(bitwise_ctr, 0),
303 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
304 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
305 ROW_FIELD_EQ(bitwise_last, 1),
306 // Err Flags
307 ROW_FIELD_EQ(bitwise_sel_tag_ff_err, 1),
308 ROW_FIELD_EQ(bitwise_sel_tag_mismatch_err, 1),
309 ROW_FIELD_EQ(bitwise_err, 1),
310 ROW_FIELD_EQ(bitwise_tag_a_inv, 0),
311 ROW_FIELD_EQ(
312 bitwise_tag_ab_diff_inv,
313 (FF(static_cast<uint8_t>(MemoryTag::FF)) - FF(static_cast<uint8_t>(MemoryTag::U16))).invert()))));
314}
315
316} // namespace
317} // namespace bb::avm2::tracegen
bitwise_trace.hpp
bb::avm2::TaggedValue::from
static TaggedValue from(T value)
Definition tagged_value.hpp:82
bb::avm2::TaggedValue::from_tag
static TaggedValue from_tag(ValueTag tag, FF value)
Definition tagged_value.cpp:227
bb::avm2::tracegen::AluTraceBuilder::process
void process(const simulation::EventEmitterInterface< simulation::AluEvent >::Container &events, TraceContainer &trace)
Process the ALU events and populate the ALU relevant columns in the trace.
Definition alu_trace.cpp:410
bb::avm2::tracegen::TestTraceContainer::as_rows
std::vector< AvmFullRowConstRef > as_rows() const
Definition test_trace_container.cpp:28
builder
AluTraceBuilder builder
Definition alu.test.cpp:124
trace
TestTraceContainer trace
Definition data_copy.test.cpp:63
ROW_FIELD_EQ
#define ROW_FIELD_EQ(field_name, expression)
Definition macros.hpp:15
memory_types.hpp
bb::avm2::FF
AvmFlavorSettings::FF FF
Definition field.hpp:10
bb::TEST
TEST(BoomerangMegaCircuitBuilder, BasicCircuit)
Definition graph_description_megacircuitbuilder.test.cpp:22
std::get
constexpr decltype(auto) get(::tuplet::tuple< T... > &&t) noexcept
Definition tuple.hpp:13
test_trace_container.hpp