The Quantum Exact Simulation Toolkit v4.1.0
Loading...
Searching...
No Matches
qureg.cpp
1/** @file
2 * Unit tests of the qureg module.
3 *
4 * @author Tyson Jones
5 *
6 * @defgroup unitqureg Qureg
7 * @ingroup unittests
8 */
9
10#include "quest.h"
11
12#include <catch2/catch_test_macros.hpp>
13#include <catch2/matchers/catch_matchers_string.hpp>
14#include <catch2/generators/catch_generators_range.hpp>
15
16#include "tests/utils/qvector.hpp"
17#include "tests/utils/qmatrix.hpp"
18#include "tests/utils/macros.hpp"
19#include "tests/utils/cache.hpp"
20#include "tests/utils/convert.hpp"
21#include "tests/utils/compare.hpp"
22#include "tests/utils/linalg.hpp"
23#include "tests/utils/random.hpp"
24
25#include <string>
26#include <algorithm>
27
28using Catch::Matchers::ContainsSubstring;
29
30
31
32/*
33 * UTILITIES
34 */
35
36#define TEST_CATEGORY \
37 LABEL_UNIT_TAG "[qureg]"
38
39
40
41/**
42 * TESTS
43 *
44 * @ingroup unitqureg
45 * @{
46 */
47
48
49TEST_CASE( "createQureg", TEST_CATEGORY ) {
50
51 SECTION( LABEL_CORRECTNESS ) {
52
53 int numQubits = GENERATE( range(1, 10) );
54 CAPTURE( numQubits );
55
56 Qureg qureg = createQureg(numQubits);
57 QuESTEnv env = getQuESTEnv();
58
59 // check fixed fields
60 REQUIRE( qureg.numQubits == numQubits );
61 REQUIRE( qureg.isDensityMatrix == 0 );
62 REQUIRE( qureg.numAmps == getPow2(numQubits) );
63 REQUIRE( qureg.logNumAmps == getLog2(qureg.numAmps) );
64 REQUIRE( qureg.logNumAmpsPerNode == getLog2(qureg.numAmpsPerNode) );
65 REQUIRE( (qureg.isMultithreaded == 0 || qureg.isMultithreaded == 1) );
66 REQUIRE( (qureg.isGpuAccelerated == 0 || qureg.isGpuAccelerated == 1) );
67 REQUIRE( (qureg.isDistributed == 0 || qureg.isDistributed == 1) );
68
69 // check deployment-specific fields
70 if (qureg.isDistributed) {
71 REQUIRE( qureg.rank == env.rank );
72 REQUIRE( qureg.numNodes == env.numNodes );
73 REQUIRE( qureg.logNumNodes == getLog2(env.numNodes) );
74 REQUIRE( qureg.numAmpsPerNode == qureg.numAmps / env.numNodes );
75 } else {
76 REQUIRE( qureg.rank == 0 );
77 REQUIRE( qureg.numNodes == 1 );
78 REQUIRE( qureg.logNumNodes == 0 );
79 REQUIRE( qureg.numAmpsPerNode == qureg.numAmps );
80 }
81
82 // check memory allocs
83 REQUIRE( qureg.cpuAmps != nullptr );
84 if (qureg.isGpuAccelerated)
85 REQUIRE( qureg.gpuAmps != nullptr );
86 if (qureg.isDistributed)
87 REQUIRE( qureg.cpuCommBuffer != nullptr );
88 if (qureg.isGpuAccelerated && qureg.isDistributed)
89 REQUIRE( qureg.gpuCommBuffer != nullptr );
90
91 /// @todo check autodeployments
92
93 // check begins in zero state
94 qvector ref = getZeroVector(qureg.numAmps); ref[0] = 1; // |0>
95 REQUIRE_AGREE( qureg, ref );
96
97 destroyQureg(qureg);
98 }
99
100 SECTION( LABEL_VALIDATION ) {
101
102 SECTION( "env not initialised" ) {
103
104 // impossible to test
105 SUCCEED( );
106 }
107
108 SECTION( "too few qubits" ) {
109
110 int numQubits = GENERATE( -1, 0 );
111
112 REQUIRE_THROWS_WITH( createQureg(numQubits), ContainsSubstring("must contain one or more qubits") );
113 }
114
115 SECTION( "too many qubits" ) {
116
117 // overflows qindex in all precisions
118 REQUIRE_THROWS_WITH( createQureg(100), ContainsSubstring("maximum which can be addressed by the qindex type") );
119
120 // overflows size_t in single precision (and ergo also in double and quad)
121 REQUIRE_THROWS_WITH( createQureg(62), ContainsSubstring("memory would overflow size_t") );
122
123 // no overflows, but definitely exceeds local RAM and fails to allocate; frightens address sanitizer!
124 // note the specific error message depends on the what backend the auto-deployer tried to use (e.g.
125 // GPU-accel or distributed) and whether memory-probers realised there was insufficient memory in
126 // advance or whether it proceeded to malloc() which subsequently failed
127 #ifndef SANITIZER_IS_ACTIVE
128 REQUIRE_THROWS_WITH( createQureg(50), ContainsSubstring("failed") || ContainsSubstring("insufficient available memory") || ContainsSubstring("available GPU memory") );
129 #endif
130 }
131 }
132}
133
134
135TEST_CASE( "createDensityQureg", TEST_CATEGORY ) {
136
137 SECTION( LABEL_CORRECTNESS ) {
138
139 int numQubits = GENERATE( range(1, 7) ); // 7qb densematr = 14qb statevec
140 CAPTURE( numQubits );
141
142 Qureg qureg = createDensityQureg(numQubits);
143 QuESTEnv env = getQuESTEnv();
144
145 // check fixed fields
146 REQUIRE( qureg.numQubits == numQubits );
147 REQUIRE( qureg.isDensityMatrix == 1 );
148 REQUIRE( qureg.numAmps == getPow2(2*numQubits) );
149 REQUIRE( qureg.logNumAmps == getLog2(qureg.numAmps) );
150 REQUIRE( qureg.logNumAmpsPerNode == getLog2(qureg.numAmpsPerNode) );
151 REQUIRE( qureg.logNumNodes == getLog2(qureg.numNodes) );
152 REQUIRE( qureg.logNumColsPerNode == getLog2(getPow2(numQubits) / qureg.numNodes) );
153 REQUIRE( qureg.numAmpsPerNode == qureg.numAmps / qureg.numNodes );
154 REQUIRE( (qureg.isMultithreaded == 0 || qureg.isMultithreaded == 1) );
155 REQUIRE( (qureg.isGpuAccelerated == 0 || qureg.isGpuAccelerated == 1) );
156 REQUIRE( (qureg.isDistributed == 0 || qureg.isDistributed == 1) );
157
158 // check deployment-specific fields
159 if (qureg.isDistributed) {
160 REQUIRE( qureg.rank == env.rank );
161 REQUIRE( qureg.numNodes == env.numNodes );
162 } else {
163 REQUIRE( qureg.rank == 0 );
164 REQUIRE( qureg.numNodes == 1 );
165 }
166
167 // check memory allocs
168 REQUIRE( qureg.cpuAmps != nullptr );
169 if (qureg.isGpuAccelerated)
170 REQUIRE( qureg.gpuAmps != nullptr );
171 if (qureg.isDistributed)
172 REQUIRE( qureg.cpuCommBuffer != nullptr );
173 if (qureg.isGpuAccelerated && qureg.isDistributed)
174 REQUIRE( qureg.gpuCommBuffer != nullptr );
175
176 /// @todo check autodeployments
177
178 // check begins in zero state
179 qmatrix ref = getZeroMatrix(getPow2(numQubits)); ref[0][0] = 1; // |0><0|
180 REQUIRE_AGREE( qureg, ref );
181
182 destroyQureg(qureg);
183 }
184
185 SECTION( LABEL_VALIDATION ) {
186
187 SECTION( "env not initialised" ) {
188
189 // impossible to test
190 SUCCEED( );
191 }
192
193 SECTION( "too few qubits" ) {
194
195 int numQubits = GENERATE( -1, 0 );
196
197 REQUIRE_THROWS_WITH( createDensityQureg(numQubits), ContainsSubstring("must contain one or more qubits") );
198 }
199
200 SECTION( "too many qubits" ) {
201
202 // overflows qindex in all precisions
203 REQUIRE_THROWS_WITH( createDensityQureg(50), ContainsSubstring("qindex type") );
204
205 // overflows size_t in single precision (and ergo also in double and quad)
206 REQUIRE_THROWS_WITH( createDensityQureg(31), ContainsSubstring("memory would overflow size_t") );
207
208 // no overflows, but definitely exceeds local RAM and fails to allocate; frightens address sanitizer!
209 // note the specific error message depends on the what backend the auto-deployer tried to use (e.g.
210 // GPU-accel or distributed) and whether memory-probers realised there was insufficient memory in
211 // advance or whether it proceeded to malloc() which subsequently failed
212 #ifndef SANITIZER_IS_ACTIVE
213 REQUIRE_THROWS_WITH( createDensityQureg(25), ContainsSubstring("failed") || ContainsSubstring("insufficient available memory") || ContainsSubstring("available GPU memory") );
214 #endif
215 }
216 }
217}
218
219
220TEST_CASE( "createForcedQureg", TEST_CATEGORY ) {
221
222 SECTION( LABEL_CORRECTNESS ) {
223
224 QuESTEnv env = getQuESTEnv();
225
226 int minNumQubits = std::max({1, env.isDistributed? getLog2(env.numNodes) : 1});
227 int maxNumQubits = std::min({minNumQubits + 10, 14});
228 int numQubits = GENERATE_COPY( range(minNumQubits, maxNumQubits) );
229 CAPTURE( numQubits );
230
231 Qureg qureg = createForcedQureg(numQubits);
232
233 // check fixed fields
234 REQUIRE( qureg.numQubits == numQubits );
235 REQUIRE( qureg.isDensityMatrix == 0 );
236 REQUIRE( qureg.numAmps == getPow2(numQubits) );
237 REQUIRE( qureg.logNumAmps == getLog2(qureg.numAmps) );
238 REQUIRE( qureg.logNumAmpsPerNode == getLog2(qureg.numAmpsPerNode) );
239
240 // check deployments
241 REQUIRE( qureg.numNodes == env.numNodes );
242 REQUIRE( qureg.logNumNodes == getLog2(env.numNodes) );
243 REQUIRE( qureg.isMultithreaded == env.isMultithreaded);
244 REQUIRE( qureg.isGpuAccelerated == env.isGpuAccelerated);
245 REQUIRE( (qureg.isDistributed == env.isDistributed || env.numNodes == 1) ); // permit auto-disable MPI
246
247 // check deployment-specific fields
248 if (qureg.isDistributed) {
249 REQUIRE( qureg.rank == env.rank );
250 REQUIRE( qureg.numAmpsPerNode == qureg.numAmps / env.numNodes );
251 } else {
252 REQUIRE( qureg.rank == 0 );
253 REQUIRE( qureg.numAmpsPerNode == qureg.numAmps );
254 }
255
256 // check memory allocs
257 REQUIRE( qureg.cpuAmps != nullptr );
258 if (qureg.isGpuAccelerated)
259 REQUIRE( qureg.gpuAmps != nullptr );
260 if (qureg.isDistributed)
261 REQUIRE( qureg.cpuCommBuffer != nullptr );
262 if (qureg.isGpuAccelerated && qureg.isDistributed)
263 REQUIRE( qureg.gpuCommBuffer != nullptr );
264
265 // check begins in zero state
266 qvector ref = getZeroVector(getPow2(numQubits)); ref[0] = 1; // |0>
267 REQUIRE_AGREE( qureg, ref );
268
269 destroyQureg(qureg);
270 }
271
272 SECTION( LABEL_VALIDATION ) {
273
274 SECTION( "env not initialised" ) {
275
276 // impossible to test
277 SUCCEED( );
278 }
279
280 SECTION( "too few qubits" ) {
281
282 REQUIRE_THROWS_WITH( createForcedQureg(-1), ContainsSubstring("must contain one or more qubits") );
283 REQUIRE_THROWS_WITH( createForcedQureg(+0), ContainsSubstring("must contain one or more qubits") );
284
285 int numNodes = getQuESTEnv().numNodes;
286 if (numNodes > 2) { // nodes=2 => min=1
287 int minNumQubits = getLog2(numNodes);
288 REQUIRE_THROWS_WITH( createForcedQureg(minNumQubits-1), ContainsSubstring("each node would contain fewer than one amplitude") );
289 }
290 }
291
292 SECTION( "too many qubits" ) {
293
294 // overflows qindex in all precisions
295 REQUIRE_THROWS_WITH( createForcedQureg(100), ContainsSubstring("maximum which can be addressed by the qindex type") );
296
297 // overflows size_t in single precision (and ergo also in double and quad)
298 REQUIRE_THROWS_WITH( createForcedQureg(62), ContainsSubstring("memory would overflow size_t") );
299
300 // no overflows, but definitely exceeds local RAM and fails to allocate; frightens address sanitizer!
301 // note the specific error message depends on the what backend the auto-deployer tried to use (e.g.
302 // GPU-accel or distributed) and whether memory-probers realised there was insufficient memory in
303 // advance or whether it proceeded to malloc() which subsequently failed
304 #ifndef SANITIZER_IS_ACTIVE
305 REQUIRE_THROWS_WITH( createForcedQureg(50), ContainsSubstring("failed") || ContainsSubstring("insufficient available memory") || ContainsSubstring("available GPU memory") );
306 #endif
307 }
308 }
309}
310
311
312TEST_CASE( "createForcedDensityQureg", TEST_CATEGORY ) {
313
314 SECTION( LABEL_CORRECTNESS ) {
315
316 QuESTEnv env = getQuESTEnv();
317
318 int minNumQubits = std::max({1, env.isDistributed? getLog2(env.numNodes) : 1});
319 int maxNumQubits = std::min({minNumQubits + 5, 8}); // 8qb densmatr = 16qb statevec
320 int numQubits = GENERATE_COPY( range(minNumQubits, maxNumQubits) );
321 CAPTURE( numQubits );
322
323 Qureg qureg = createForcedDensityQureg(numQubits);
324
325 // check fixed fields
326 REQUIRE( qureg.numQubits == numQubits );
327 REQUIRE( qureg.isDensityMatrix == 1 );
328 REQUIRE( qureg.numAmps == getPow2(2*numQubits) );
329 REQUIRE( qureg.logNumAmps == getLog2(qureg.numAmps) );
330 REQUIRE( qureg.logNumAmpsPerNode == getLog2(qureg.numAmpsPerNode) );
331 REQUIRE( qureg.logNumColsPerNode == getLog2(getPow2(numQubits) / qureg.numNodes) );
332
333 // check deployments
334 REQUIRE( qureg.numNodes == env.numNodes );
335 REQUIRE( qureg.logNumNodes == getLog2(env.numNodes) );
336 REQUIRE( qureg.isMultithreaded == env.isMultithreaded);
337 REQUIRE( qureg.isGpuAccelerated == env.isGpuAccelerated);
338 REQUIRE( (qureg.isDistributed == env.isDistributed || env.numNodes == 1) ); // permit auto-disable MPI
339
340 // check deployment-specific fields
341 if (qureg.isDistributed) {
342 REQUIRE( qureg.rank == env.rank );
343 REQUIRE( qureg.numAmpsPerNode == qureg.numAmps / env.numNodes );
344 } else {
345 REQUIRE( qureg.rank == 0 );
346 REQUIRE( qureg.numAmpsPerNode == qureg.numAmps );
347 }
348
349 // check memory allocs
350 REQUIRE( qureg.cpuAmps != nullptr );
351 if (qureg.isGpuAccelerated)
352 REQUIRE( qureg.gpuAmps != nullptr );
353 if (qureg.isDistributed)
354 REQUIRE( qureg.cpuCommBuffer != nullptr );
355 if (qureg.isGpuAccelerated && qureg.isDistributed)
356 REQUIRE( qureg.gpuCommBuffer != nullptr );
357
358 // check begins in zero state
359 qmatrix ref = getZeroMatrix(getPow2(numQubits)); ref[0][0] = 1; // |0><0|
360 REQUIRE_AGREE( qureg, ref );
361
362 destroyQureg(qureg);
363 }
364
365 SECTION( LABEL_VALIDATION ) {
366
367 SECTION( "env not initialised" ) {
368
369 // impossible to test
370 SUCCEED( );
371 }
372
373 SECTION( "too few qubits" ) {
374
375 REQUIRE_THROWS_WITH( createForcedDensityQureg(-1), ContainsSubstring("must contain one or more qubits") );
376 REQUIRE_THROWS_WITH( createForcedDensityQureg(+0), ContainsSubstring("must contain one or more qubits") );
377
378 int numNodes = getQuESTEnv().numNodes;
379 if (numNodes > 2) { // nodes=2 => min=1
380 int minNumQubits = getLog2(numNodes);
381 REQUIRE_THROWS_WITH( createForcedDensityQureg(minNumQubits-1), ContainsSubstring("each node would contain fewer than a column") );
382 }
383 }
384
385 SECTION( "too many qubits" ) {
386
387 // overflows qindex in all precisions
388 REQUIRE_THROWS_WITH( createForcedDensityQureg(50), ContainsSubstring("qindex type") );
389
390 // overflows size_t in single precision (and ergo also in double and quad)
391 REQUIRE_THROWS_WITH( createForcedDensityQureg(31), ContainsSubstring("memory would overflow size_t") );
392
393 // no overflows, but definitely exceeds local RAM and fails to allocate; frightens address sanitizer!
394 // note the specific error message depends on the what backend the auto-deployer tried to use (e.g.
395 // GPU-accel or distributed) and whether memory-probers realised there was insufficient memory in
396 // advance or whether it proceeded to malloc() which subsequently failed
397 #ifndef SANITIZER_IS_ACTIVE
398 REQUIRE_THROWS_WITH( createForcedDensityQureg(25), ContainsSubstring("failed") || ContainsSubstring("insufficient available memory") || ContainsSubstring("available GPU memory") );
399 #endif
400 }
401 }
402}
403
404
405TEST_CASE( "createCustomQureg", TEST_CATEGORY ) {
406
407 SECTION( LABEL_CORRECTNESS ) {
408
409 QuESTEnv env = getQuESTEnv();
410
411 for (auto [deployLabel, mpi, gpu, omp] : getSupportedDeployments()) {
412
413 int isDenseMatr = GENERATE( 0, 1 );
414
415 std::string quregLabel = (isDenseMatr)? LABEL_STATEVEC : LABEL_DENSMATR;
416 std::string secLabel = quregLabel + LABEL_DELIMITER + deployLabel;
417
418 SECTION( secLabel ) {
419
420 int minNumQubits = std::max({1, mpi? getLog2(env.numNodes) : 1});
421 int maxNumQubits = std::min({minNumQubits + 3, isDenseMatr? 6 : 12});
422 int numQubits = GENERATE_COPY( range(minNumQubits, maxNumQubits) );
423 CAPTURE( numQubits );
424
425 Qureg qureg = createCustomQureg(numQubits, isDenseMatr, mpi, gpu, omp);
426
427 // check fixed fields
428 REQUIRE( qureg.numQubits == numQubits );
429 REQUIRE( qureg.isDensityMatrix == isDenseMatr );
430 REQUIRE( qureg.numAmps == getPow2(numQubits * (isDenseMatr? 2:1)) );
431 REQUIRE( qureg.logNumNodes == getLog2(qureg.numNodes) );
432 REQUIRE( qureg.logNumAmps == getLog2(qureg.numAmps) );
433 REQUIRE( qureg.logNumAmpsPerNode == getLog2(qureg.numAmpsPerNode) );
434 REQUIRE( qureg.logNumColsPerNode == (isDenseMatr? getLog2(getPow2(numQubits) / qureg.numNodes) : 0) );
435
436 // check deployments
437 REQUIRE( qureg.isMultithreaded == omp );
438 REQUIRE( qureg.isGpuAccelerated == gpu );
439 REQUIRE( (qureg.isDistributed == mpi || env.numNodes == 1) ); // permit auto-disable MPI
440
441 // check deployment-specific fields
442 if (mpi) {
443 REQUIRE( qureg.rank == env.rank );
444 REQUIRE( qureg.numNodes == env.numNodes );
445 REQUIRE( qureg.numAmpsPerNode == qureg.numAmps / env.numNodes );
446 } else {
447 REQUIRE( qureg.rank == 0 );
448 REQUIRE( qureg.numNodes == 1 );
449 REQUIRE( qureg.numAmpsPerNode == qureg.numAmps );
450 }
451
452 // check memory allocs
453 REQUIRE( qureg.cpuAmps != nullptr );
454 if (qureg.isGpuAccelerated)
455 REQUIRE( qureg.gpuAmps != nullptr );
456 if (qureg.isDistributed)
457 REQUIRE( qureg.cpuCommBuffer != nullptr );
458 if (qureg.isGpuAccelerated && qureg.isDistributed)
459 REQUIRE( qureg.gpuCommBuffer != nullptr );
460
461 // check begins in zero state
462 if (isDenseMatr) {
463 qmatrix ref = getZeroMatrix(getPow2(numQubits)); ref[0][0] = 1; // |0><0|
464 REQUIRE_AGREE( qureg, ref );
465 } else {
466 qvector ref = getZeroVector(getPow2(numQubits)); ref[0] = 1; // |0>
467 REQUIRE_AGREE( qureg, ref );
468 }
469
470 destroyQureg(qureg);
471 }
472 }
473 }
474
475 SECTION( LABEL_VALIDATION ) {
476
477 SECTION( "env not initialised" ) {
478
479 // impossible to test
480 SUCCEED( );
481 }
482
483 SECTION( "invalid isDensityMatrix flag" ) {
484
485 int isDensMatr = GENERATE( -1, 2 );
486
487 REQUIRE_THROWS_WITH( createCustomQureg(10, isDensMatr, 0,0,0), ContainsSubstring("isDensityMatrix") );
488 }
489
490 SECTION( "unsupported deployment" ) {
491
492 QuESTEnv env = getQuESTEnv();
493 const int numQubits = 10;
494 const int isDensMatr = 0;
495
496 if (!env.isDistributed)
497 REQUIRE_THROWS_WITH( createCustomQureg(numQubits,isDensMatr, 1,0,0), ContainsSubstring("non-distributed") );
498
499 if (!env.isGpuAccelerated)
500 REQUIRE_THROWS_WITH( createCustomQureg(numQubits,isDensMatr, 0,1,0), ContainsSubstring("non-GPU") );
501
502 if (!env.isMultithreaded)
503 REQUIRE_THROWS_WITH( createCustomQureg(numQubits,isDensMatr, 0,0,1), ContainsSubstring("non-multithreaded") );
504 }
505
506 SECTION( "too few qubits" ) {
507
508 REQUIRE_THROWS_WITH( createCustomQureg(-1, 0,0,0,0), ContainsSubstring("must contain one or more qubits") );
509 REQUIRE_THROWS_WITH( createCustomQureg(+0, 0,0,0,0), ContainsSubstring("must contain one or more qubits") );
510
511 int numNodes = getQuESTEnv().numNodes;
512 if (numNodes > 2) { // nodes=2 => min=1
513 int minNumQubits = getLog2(numNodes);
514 int useDistrib = 1;
515 REQUIRE_THROWS_WITH( createCustomQureg(minNumQubits-1,0, useDistrib,0,0), ContainsSubstring("each node would contain fewer than one amplitude") );
516 }
517 }
518
519 SECTION( "too many qubits" ) {
520
521 // overflows qindex in all precisions
522 REQUIRE_THROWS_WITH( createCustomQureg(100, 0, 0,0,0), ContainsSubstring("qindex") );
523 REQUIRE_THROWS_WITH( createCustomQureg(50, 1, 0,0,0), ContainsSubstring("qindex") );
524
525 // overflows size_t in single precision (and ergo also in double and quad)
526 REQUIRE_THROWS_WITH( createCustomQureg(62, 0, 0,0,0), ContainsSubstring("memory would overflow size_t") );
527 REQUIRE_THROWS_WITH( createCustomQureg(31, 1, 0,0,0), ContainsSubstring("memory would overflow size_t") );
528
529 // no overflows, but definitely exceeds local RAM and fails to allocate; frightens address sanitizer!
530 // note the specific error message depends on the what backend the auto-deployer tried to use (e.g.
531 // GPU-accel or distributed) and whether memory-probers realised there was insufficient memory in
532 // advance or whether it proceeded to malloc() which subsequently failed
533 #ifndef SANITIZER_IS_ACTIVE
534 REQUIRE_THROWS_WITH( createCustomQureg(50, 0, 0,0,0), ContainsSubstring("failed") || ContainsSubstring("insufficient available memory") || ContainsSubstring("available GPU memory") );
535 REQUIRE_THROWS_WITH( createCustomQureg(25, 1, 0,0,0), ContainsSubstring("failed") || ContainsSubstring("insufficient available memory") || ContainsSubstring("available GPU memory") );
536 #endif
537 }
538 }
539}
540
541
542TEST_CASE( "createCloneQureg", TEST_CATEGORY ) {
543
544 SECTION( LABEL_CORRECTNESS ) {
545
546 auto cache = GENERATE( getCachedStatevecs(), getCachedDensmatrs() );
547
548 for (auto& [label, qureg]: cache) {
549
550 initRandomPureState(qureg);
551 Qureg clone = createCloneQureg(qureg);
552
553 // check identical fields
554 REQUIRE( clone.isMultithreaded == qureg.isMultithreaded );
555 REQUIRE( clone.isGpuAccelerated == qureg.isGpuAccelerated );
556 REQUIRE( clone.isDistributed == qureg.isDistributed );
557 REQUIRE( clone.rank == qureg.rank );
558 REQUIRE( clone.numNodes == qureg.numNodes );
559 REQUIRE( clone.logNumNodes == qureg.logNumNodes );
560 REQUIRE( clone.isDensityMatrix == qureg.isDensityMatrix );
561 REQUIRE( clone.numQubits == qureg.numQubits );
562 REQUIRE( clone.numAmps == qureg.numAmps );
563 REQUIRE( clone.logNumAmps == qureg.logNumAmps );
564 REQUIRE( clone.numAmpsPerNode == qureg.numAmpsPerNode );
565 REQUIRE( clone.logNumAmpsPerNode == qureg.logNumAmpsPerNode );
566 REQUIRE( clone.logNumColsPerNode == qureg.logNumColsPerNode );
567
568 // check memory is different
569 REQUIRE( clone.cpuAmps != qureg.cpuAmps );
570 if (clone.isGpuAccelerated)
571 REQUIRE( clone.gpuAmps != qureg.gpuAmps );
572 if (clone.isDistributed)
573 REQUIRE( clone.cpuCommBuffer != qureg.cpuCommBuffer );
574 if (clone.isGpuAccelerated && clone.isDistributed)
575 REQUIRE( clone.gpuCommBuffer != qureg.gpuCommBuffer );
576
577 // check identical states
578 REQUIRE_AGREE( clone, qureg );
579
580 destroyQureg(clone);
581 }
582 }
583}
584
585
586TEST_CASE( "destroyQureg", TEST_CATEGORY ) {
587
588 SECTION( LABEL_CORRECTNESS ) {
589
590 Qureg qureg = createQureg(5);
591 REQUIRE_NOTHROW( destroyQureg(qureg) );
592 }
593
594 SECTION( LABEL_VALIDATION ) {
595
596 /// @todo fails in MSVC for unknown reason
597 #ifndef _MSC_VER
598 // sanitizer messes with default initialisation
599 #ifndef SANITIZER_IS_ACTIVE
600 SECTION( "not created" ) {
601
602 Qureg qureg;
603 REQUIRE_THROWS_WITH( destroyQureg(qureg), ContainsSubstring("invalid Qureg") );
604 }
605 #endif
606 #endif
607 }
608}
609
610
611TEST_CASE( "getQuregAmp", TEST_CATEGORY ) {
612
613 SECTION( LABEL_CORRECTNESS ) {
614
615 for (auto& [label, qureg]: getCachedStatevecs()) {
616
617 qvector ref = getRefStatevec();
618 initDebugState(qureg);
619 setToDebugState(ref);
620
621 int index = GENERATE_COPY( range(0, (int) qureg.numAmps) );
622 CAPTURE( index );
623
624 // not necessarily identical when qureg is GPU-accelerated
625 REQUIRE_AGREE( getQuregAmp(qureg, index), ref[index] );
626 }
627 }
628
629 SECTION( LABEL_VALIDATION ) {
630
631 /// @todo fails in MSVC for unknown reason
632 #ifndef _MSC_VER
633 // sanitizer messes with default initialisation
634 #ifndef SANITIZER_IS_ACTIVE
635 SECTION( "not created" ) {
636
637 Qureg qureg;
638 REQUIRE_THROWS_WITH( getQuregAmp(qureg,0), ContainsSubstring("invalid Qureg") );
639 }
640 #endif
641 #endif
642
643 SECTION( "invalid index" ) {
644
645 int numQubits = GENERATE( range(1,5) );
646 Qureg qureg = createQureg(numQubits);
647 int index = GENERATE_COPY( -1, getPow2(numQubits), getPow2(numQubits) + 1 );
648
649 REQUIRE_THROWS_WITH( getQuregAmp(qureg,index), ContainsSubstring("state index") && ContainsSubstring("is invalid") );
650
651 destroyQureg(qureg);
652 }
653
654 SECTION( "densitymatrix" ) {
655
656 Qureg qureg = createDensityQureg(1);
657
658 REQUIRE_THROWS_WITH( getQuregAmp(qureg,0), ContainsSubstring("received a density matrix") );
659
660 destroyQureg(qureg);
661 }
662 }
663}
664
665
666TEST_CASE( "getDensityQuregAmp", TEST_CATEGORY ) {
667
668 SECTION( LABEL_CORRECTNESS ) {
669
670 for (auto& [label, qureg]: getCachedDensmatrs()) {
671
672 qmatrix ref = getRefDensmatr();
673 initDebugState(qureg);
674 setToDebugState(ref);
675
676 int dim = (int) getPow2(qureg.numQubits);
677 int row = getRandomInt(0, dim);
678 int col = getRandomInt(0, dim);
679
680 GENERATE( range(0,100) );
681 CAPTURE( row, col );
682
683 // not necessarily identical when qureg is GPU-accelerated
684 REQUIRE_AGREE( getDensityQuregAmp(qureg, row, col), ref[row][col] );
685 }
686 }
687
688 SECTION( LABEL_VALIDATION ) {
689
690 /// @todo fails in MSVC for unknown reason
691 #ifndef _MSC_VER
692 // sanitizer messes with default initialisation
693 #ifndef SANITIZER_IS_ACTIVE
694 SECTION( "not created" ) {
695
696 Qureg qureg;
697 REQUIRE_THROWS_WITH( getDensityQuregAmp(qureg,0,0), ContainsSubstring("invalid Qureg") );
698 }
699 #endif
700 #endif
701
702 SECTION( "invalid indices" ) {
703
704 int numQubits = GENERATE( range(1,5) );
705 Qureg qureg = createDensityQureg(numQubits);
706 qindex index = GENERATE_COPY( -1, getPow2(numQubits), getPow2(numQubits) + 1 );
707
708 REQUIRE_THROWS_WITH( getDensityQuregAmp(qureg,0,index), ContainsSubstring("A") );
709 REQUIRE_THROWS_WITH( getDensityQuregAmp(qureg,index,0), ContainsSubstring("B") );
710
711 destroyQureg(qureg);
712 }
713
714 SECTION( "statevector" ) {
715
716 Qureg qureg = createQureg(1);
717
718 REQUIRE_THROWS_WITH( getDensityQuregAmp(qureg,0,0), ContainsSubstring("received a statevector") );
719
720 destroyQureg(qureg);
721 }
722 }
723}
724
725
726TEST_CASE( "getQuregAmps", TEST_CATEGORY ) {
727
728 SECTION( LABEL_CORRECTNESS ) {
729
730 for (auto& [label, qureg]: getCachedStatevecs()) {
731
732 qvector ref = getRefStatevec();
733 initDebugState(qureg);
734 setToDebugState(ref);
735
736 GENERATE( range(0,100) );
737 int startInd = getRandomInt(0, qureg.numAmps);
738 int numAmps = getRandomInt(0, qureg.numAmps - startInd + 1);
739
740 vector<qcomp> out(numAmps);
741 getQuregAmps(out.data(), qureg, startInd, numAmps);
742
743 // not necessarily identical when qureg is GPU-accelerated
744 REQUIRE_AGREE( out, getSublist(ref, startInd, numAmps) );
745 }
746 }
747
748 SECTION( LABEL_VALIDATION ) {
749
750 Qureg qureg = createQureg(5);
751
752 /// @todo fails in MSVC for unknown reason
753 #ifndef _MSC_VER
754 // sanitizer messes with default initialisation
755 #ifndef SANITIZER_IS_ACTIVE
756 SECTION( "not created" ) {
757
758 Qureg bad;
759 REQUIRE_THROWS_WITH( getQuregAmps(nullptr,bad,0,0), ContainsSubstring("invalid Qureg") );
760 }
761 #endif
762 #endif
763
764 SECTION( "indices" ) {
765
766 int startInd = GENERATE_COPY( -1, qureg.numAmps, qureg.numAmps + 1 );
767
768 REQUIRE_THROWS_WITH( getQuregAmps(nullptr,qureg,startInd,0), ContainsSubstring("starting basis state index") );
769 }
770
771 SECTION( "num amps") {
772
773 int numOut = GENERATE_COPY( -1, qureg.numAmps + 1 );
774
775 REQUIRE_THROWS_WITH( getQuregAmps(nullptr,qureg,0,numOut), ContainsSubstring("number of amplitudes") );
776 }
777
778 SECTION( "subrange" ) {
779
780 int numOut = 10;
781
782 REQUIRE_THROWS_WITH( getQuregAmps(nullptr,qureg, qureg.numAmps - numOut, numOut + 1), ContainsSubstring("implies an end index") );
783 }
784
785 destroyQureg(qureg);
786 }
787}
788
789
790TEST_CASE( "getDensityQuregAmps", TEST_CATEGORY ) {
791
792 SECTION( LABEL_CORRECTNESS ) {
793
794 for (auto& [label, qureg]: getCachedDensmatrs()) {
795
796 qmatrix ref = getRefDensmatr();
797 initDebugState(qureg);
798 setToDebugState(ref);
799
800 GENERATE( range(0,100) );
801
802 auto startRow = getRandomInt(0, ref.size());
803 auto startCol = getRandomInt(0, ref.size());
804 auto numRows = getRandomInt(1, ref.size() - startRow);
805 auto numCols = getRandomInt(1, ref.size() - startCol);
806
807 qcomp** out = (qcomp**) malloc(numRows * sizeof *out);
808 for (int i=0; i<numRows; i++)
809 out[i] = (qcomp*) malloc(numCols * sizeof **out);
810
811 getDensityQuregAmps(out, qureg, startRow, startCol, numRows, numCols);
812
813 bool agrees = true;
814 for (int r=0; r<numRows && agrees; r++)
815 for (int c=0; c<numCols && agrees; c++)
816 agrees = doScalarsAgree(out[r][c], ref[startRow+r][startCol+c]);
817
818 REQUIRE( agrees );
819
820 for (int i=0; i<numRows; i++)
821 free(out[i]);
822 free(out);
823 }
824 }
825
826 SECTION( LABEL_VALIDATION ) {
827
828 Qureg qureg = createDensityQureg(5);
829
830 /// @todo fails in MSVC for unknown reason
831 #ifndef _MSC_VER
832 // sanitizer messes with default initialisation
833 #ifndef SANITIZER_IS_ACTIVE
834 SECTION( "not created" ) {
835
836 Qureg bad;
837 REQUIRE_THROWS_WITH( getDensityQuregAmps(nullptr,bad,0,0,0,0), ContainsSubstring("invalid Qureg") );
838 }
839 #endif
840 #endif
841
842 SECTION( "indices" ) {
843
844 int startInd = GENERATE_COPY( -1, qureg.numAmps, qureg.numAmps + 1 );
845
846 REQUIRE_THROWS_WITH( getDensityQuregAmps(nullptr,qureg, startInd,0, 0,0), ContainsSubstring("Either or both of the starting row and column") );
847 REQUIRE_THROWS_WITH( getDensityQuregAmps(nullptr,qureg, 0,startInd, 0,0), ContainsSubstring("Either or both of the starting row and column") );
848 }
849
850 SECTION( "num amps") {
851
852 int numOut = GENERATE_COPY( -1, qureg.numAmps + 1 );
853
854 REQUIRE_THROWS_WITH( getDensityQuregAmps(nullptr,qureg, 0,0, 0,numOut), ContainsSubstring("Either or both of the number of rows and columns") );
855 REQUIRE_THROWS_WITH( getDensityQuregAmps(nullptr,qureg, 0,0, numOut,0), ContainsSubstring("Either or both of the number of rows and columns") );
856 }
857
858 SECTION( "subrange" ) {
859
860 int numOut = 10;
861 int dim = getPow2(qureg.numQubits);
862
863 REQUIRE_THROWS_WITH( getDensityQuregAmps(nullptr,qureg, dim-numOut,0, numOut + 1,1), ContainsSubstring("combination of starting") && ContainsSubstring("number of rows and columns") );
864 REQUIRE_THROWS_WITH( getDensityQuregAmps(nullptr,qureg, 0,dim-numOut, 1,numOut + 1), ContainsSubstring("combination of starting") && ContainsSubstring("number of rows and columns") );
865 }
866
867 destroyQureg(qureg);
868 }
869}
870
871
872/** @} (end defgroup) */
873
874
875
876/**
877 * @todo
878 * UNTESTED FUNCTIONS
879 */
880
881void reportQuregParams(Qureg qureg);
882void reportQureg(Qureg qureg);
883
884void syncQuregToGpu (Qureg qureg);
885void syncQuregFromGpu(Qureg qureg);
886
887void syncSubQuregToGpu (Qureg qureg, qindex localStartInd, qindex numLocalAmps);
888void syncSubQuregFromGpu(Qureg qureg, qindex localStartInd, qindex numLocalAmps);
getQuESTEnv
QuESTEnv getQuESTEnv()
Definition environment.cpp:401
initRandomPureState
void initRandomPureState(Qureg qureg)
Definition initialisations.cpp:121
initDebugState
void initDebugState(Qureg qureg)
Definition initialisations.cpp:96
createDensityQureg
Qureg createDensityQureg(int numQubits)
Definition qureg.cpp:290
createForcedQureg
Qureg createForcedQureg(int numQubits)
Definition qureg.cpp:298
createForcedDensityQureg
Qureg createForcedDensityQureg(int numQubits)
Definition qureg.cpp:308
createCloneQureg
Qureg createCloneQureg(Qureg qureg)
Definition qureg.cpp:318
createCustomQureg
Qureg createCustomQureg(int numQubits, int isDensMatr, int useDistrib, int useGpuAccel, int useMultithread)
Definition qureg.cpp:276
createQureg
Qureg createQureg(int numQubits)
Definition qureg.cpp:282
destroyQureg
void destroyQureg(Qureg qureg)
Definition qureg.cpp:333
getQuregAmp
qcomp getQuregAmp(Qureg qureg, qindex index)
Definition qureg.cpp:487
getDensityQuregAmps
void getDensityQuregAmps(qcomp **outAmps, Qureg qureg, qindex startRow, qindex startCol, qindex numRows, qindex numCols)
Definition qureg.cpp:460
getQuregAmps
void getQuregAmps(qcomp *outAmps, Qureg qureg, qindex startInd, qindex numAmps)
Definition qureg.cpp:451
getDensityQuregAmp
qcomp getDensityQuregAmp(Qureg qureg, qindex row, qindex column)
Definition qureg.cpp:500
reportQureg
void reportQureg(Qureg qureg)
Definition qureg.cpp:374
reportQuregParams
void reportQuregParams(Qureg qureg)
Definition qureg.cpp:356
syncQuregFromGpu
void syncQuregFromGpu(Qureg qureg)
Definition qureg.cpp:402
syncSubQuregToGpu
void syncSubQuregToGpu(Qureg qureg, qindex localStartInd, qindex numLocalAmps)
Definition qureg.cpp:411
syncSubQuregFromGpu
void syncSubQuregFromGpu(Qureg qureg, qindex localStartInd, qindex numLocalAmps)
Definition qureg.cpp:430
syncQuregToGpu
void syncQuregToGpu(Qureg qureg)
Definition qureg.cpp:395
getZeroMatrix
qmatrix getZeroMatrix(size_t dim)
Definition qmatrix.cpp:18
getRandomInt
int getRandomInt(int min, int maxExcl)
Definition random.cpp:90
TEST_CASE
TEST_CASE("createQureg", TEST_CATEGORY)
Definition qureg.cpp:49
Qureg
Definition qureg.h:49