separated source (C++17) and testing (C++20) standards

This required editing the source to exclude designated initialisers which are not supported in C++17 except through compiler extensions. Such extensions are enabled by default in Clang and GCC but require explicit enabling in e.g. MSVC. We've here made the decision to widen default-compiler support by making struct initialisation a little uglier.

Author: TysonRayJones

CMakeLists.txt

@@ -278,11 +278,18 @@ set_target_properties(QuEST PROPERTIES
         SOVERSION   ${PROJECT_VERSION_MAJOR}
 )
 
-# Add required C and C++ standards
+# Add required C and C++ standards.
+# Note the QuEST interface(s) require only C11 and C++14, 
+# while the source code is entirely C++ and requires C++17,
+# and the tests further require C++20 (handled in tests/).
+# Yet, we here specify C++17 for the source, and C11 as only
+# applies to the C interface when users specify USER_SOURCE,
+# to attemptedly minimise user confusion. Users wishing to
+# link QuEST with C++14 should separate compilation.
 target_compile_features(QuEST
   PUBLIC
   c_std_11
-  cxx_std_20
+  cxx_std_17
 )
 
 # Turn on all compiler warnings

quest/include/matrices.h

@@ -9,6 +9,10 @@
  * definitions, for safety. Some intendedly private functions are necessarily
  * exposed here to the user, and are prefixed with an underscore.
  * 
+ * Note too that designated initialisers are generally avoided, since while
+ * C99/C11 compatible, they are not explicitly supported by C++14 (only from
+ * C++20) except through compiler extensions
+ * 
  * @author Tyson Jones
  * @author Richard Meister (aided in design)
  * @author Erich Essmann (aided in design, patched on MSVC)
@@ -321,13 +325,14 @@ extern void _validateNewElemsPtrNotNull(qcomp* ptr, const char* caller);
 static inline CompMatr1 getCompMatr1(qcomp** in) {
     _validateNewNestedElemsPtrNotNull(in, 1, __func__);
 
-    CompMatr1 out = {
-        .numQubits = 1,
-        .numRows = 2,
-        .elems = {
-            {in[0][0], in[0][1]}, 
-            {in[1][0], in[1][1]}}
-    };
+    CompMatr1 out;
+
+    out.numQubits = 1;
+    out.numRows = 2;
+    for (int r=0; r<2; r++)
+        for (int c=0; c<2; c++)
+            out.elems[r][c] = in[r][c];
+
     return out;
 }
 
@@ -346,15 +351,14 @@ static inline CompMatr1 getCompMatr1(qcomp** in) {
 static inline CompMatr2 getCompMatr2(qcomp** in) {
     _validateNewNestedElemsPtrNotNull(in, 2, __func__);
 
-    CompMatr2 out = {
-        .numQubits = 2,
-        .numRows = 4,
-        .elems = {
-            {in[0][0], in[0][1], in[0][2], in[0][3]},
-            {in[1][0], in[1][1], in[1][2], in[1][3]},
-            {in[2][0], in[2][1], in[2][2], in[2][3]},
-            {in[3][0], in[3][1], in[3][2], in[3][3]}}
-    };
+    CompMatr2 out;
+
+    out.numQubits = 2;
+    out.numRows = 4;
+    for (int r=0; r<4; r++)
+        for (int c=0; c<4; c++)
+            out.elems[r][c] = in[r][c];
+    
     return out;
 }
 
@@ -374,11 +378,13 @@ static inline CompMatr2 getCompMatr2(qcomp** in) {
 static inline DiagMatr1 getDiagMatr1(qcomp* in) {
     _validateNewElemsPtrNotNull(in, __func__);
 
-    DiagMatr1 out = {
-        .numQubits = 1,
-        .numElems = 2,
-        .elems = {in[0], in[1]}
-    };
+    DiagMatr1 out;
+
+    out.numQubits = 1;
+    out.numElems = 2;
+    for (int i=0; i<2; i++)
+        out.elems[i] = in[i];
+
     return out;
 }
 
@@ -397,11 +403,13 @@ static inline DiagMatr1 getDiagMatr1(qcomp* in) {
 static inline DiagMatr2 getDiagMatr2(qcomp* in) {
     _validateNewElemsPtrNotNull(in, __func__);
 
-    DiagMatr2 out = {
-        .numQubits = 2,
-        .numElems = 4,
-        .elems = {in[0], in[1], in[2], in[3]}
-    };
+    DiagMatr2 out;
+    
+    out.numQubits = 2;
+    out.numElems = 4;
+    for (int i=0; i<4; i++)
+        out.elems[i] = in[i];
+
     return out;
 }
 

quest/src/api/channels.cpp

@@ -131,26 +131,30 @@ SuperOp allocSuperOp(int numQubits) {
     qindex numRows = powerOf2(2 * numQubits);
     qindex numElems = numRows * numRows;
 
+    // attempt top allocate 1D memory
     qcomp* cpuMem = cpu_allocArray(numElems); // nullptr if failed
     qcomp* gpuMem = nullptr;
     if (getQuESTEnv().isGpuAccelerated)
         gpuMem = gpu_allocArray(numElems); // nullptr if failed
 
-    SuperOp out = {
-        .numQubits = numQubits,
-        .numRows = numRows,
+    // prepare output SuperOp (avoiding C++20 designated initialiser)
+    SuperOp out;
+    out.numQubits = numQubits;
+    out.numRows = numRows;
 
-        .cpuElems = cpu_allocAndInitMatrixWrapper(cpuMem, numRows), // nullptr if failed
-        .cpuElemsFlat = cpuMem,
-        .gpuElemsFlat = gpuMem,
+    // attemptedly allocate 2D alias for 1D CPU memory
+    out.cpuElems = cpu_allocAndInitMatrixWrapper(cpuMem, numRows); // nullptr if failed
+    out.cpuElemsFlat = cpuMem;
+    out.gpuElemsFlat = gpuMem;
 
-        .wasGpuSynced = cpu_allocHeapFlag() // nullptr if failed
-    };
+    // attemptedly allocate (un-initialised) flags in the heap so that struct copies are mutable
+    out.wasGpuSynced = cpu_allocHeapFlag(); // nullptr if failed
 
     // if heap flag allocated, mark it as unsynced (caller will handle if allocation failed)
     if (mem_isAllocated(out.wasGpuSynced))
         *(out.wasGpuSynced) = 0;
 
+    // caller will handle if any above allocations failed
     return out;
 }
 
@@ -176,16 +180,14 @@ extern "C" KrausMap createKrausMap(int numQubits, int numOperators) {
     // validation ensures this never overflows
     qindex numRows = powerOf2(numQubits);
 
-    KrausMap out = {
-        .numQubits = numQubits,
-        .numMatrices = numOperators,
-        .numRows = numRows,
-
-        .matrices = cpu_allocMatrixList(numRows, numOperators), // is or contains nullptr if failed
-        .superop = allocSuperOp(numQubits), // heap fields are or contain nullptr if failed
-
-        .isApproxCPTP = util_allocEpsilonSensitiveHeapFlag(), // nullptr if failed
-    };
+    // attempt to allocate output KrausMap fields (avoiding C++20 designated initialiser)
+    KrausMap out;
+    out.numQubits = numQubits,
+    out.numMatrices = numOperators,
+    out.numRows = numRows,
+    out.matrices = cpu_allocMatrixList(numRows, numOperators); // is or contains nullptr if failed
+    out.superop = allocSuperOp(numQubits); // heap fields are or contain nullptr if failed
+    out.isApproxCPTP = util_allocEpsilonSensitiveHeapFlag(); // nullptr if failed
 
     // free memory before throwing validation error to avoid memory leaks
     freeAllMemoryIfAnyAllocsFailed(out); // sets out.matrices=nullptr if failed

quest/src/api/environment.cpp

@@ -130,21 +130,14 @@ void validateAndInitCustomQuESTEnv(int useDistrib, int useGpuAccel, int useMulti
     if (globalEnvPtr == nullptr)
         error_allocOfQuESTEnvFailed();
 
-    /// @todo the below memcpy is naughty (QuESTEnv has no trivial copy-assignment) and causes compiler warning. Fix!
-
-    // initialise it to a local env
-    QuESTEnv env = {
-
-        // bind deployment info
-        .isMultithreaded  = useMultithread,
-        .isGpuAccelerated = useGpuAccel,
-        .isDistributed    = useDistrib,
-
-        // set distributed info
-        .rank     = (useDistrib)? comm_getRank()     : 0,
-        .numNodes = (useDistrib)? comm_getNumNodes() : 1,
-    };
-    memcpy(globalEnvPtr, &env, sizeof(QuESTEnv));
+    // bind deployment info to global instance
+    globalEnvPtr->isMultithreaded  = useMultithread;
+    globalEnvPtr->isGpuAccelerated = useGpuAccel;
+    globalEnvPtr->isDistributed    = useDistrib;
+
+    // bind distributed info
+    globalEnvPtr->rank     = (useDistrib)? comm_getRank()     : 0;
+    globalEnvPtr->numNodes = (useDistrib)? comm_getNumNodes() : 1;
 }
 
 

quest/src/api/matrices.cpp

@@ -216,26 +216,26 @@ extern "C" CompMatr createCompMatr(int numQubits) {
     qindex numRows = powerOf2(numQubits);
     qindex numElems = numRows * numRows;
 
+    // attempt to allocate 1D memory
     qcomp* cpuMem = cpu_allocArray(numElems); // nullptr if failed
     qcomp* gpuMem = nullptr;
     if (getQuESTEnv().isGpuAccelerated)
         gpuMem = gpu_allocArray(numElems); // nullptr if failed
 
-    // initialise all CompMatr fields inline because most are const
-    CompMatr out = {
-        .numQubits = numQubits,
-        .numRows = numRows,
+    // prepare output CompMatr (avoiding C++20 designated initialiser)
+    CompMatr out;
+    out.numQubits = numQubits;
+    out.numRows = numRows;
 
-        // allocate flags in the heap so that struct copies are mutable
-        .isApproxUnitary    = util_allocEpsilonSensitiveHeapFlag(), // nullptr if failed
-        .isApproxHermitian  = util_allocEpsilonSensitiveHeapFlag(),
+    // attemptedly allocate (un-initialised) flags in the heap so that struct copies are mutable
+    out.isApproxUnitary    = util_allocEpsilonSensitiveHeapFlag(); // nullptr if failed
+    out.isApproxHermitian  = util_allocEpsilonSensitiveHeapFlag();
+    out.wasGpuSynced = cpu_allocHeapFlag(); // nullptr if failed
 
-        .wasGpuSynced = cpu_allocHeapFlag(), // nullptr if failed
-
-        .cpuElems = cpu_allocAndInitMatrixWrapper(cpuMem, numRows), // nullptr if failed
-        .cpuElemsFlat = cpuMem,
-        .gpuElemsFlat = gpuMem
-    };
+    // attemptedly allocate 2D alias for 1D CPU memory
+    out.cpuElems = cpu_allocAndInitMatrixWrapper(cpuMem, numRows); // nullptr if failed
+    out.cpuElemsFlat = cpuMem;
+    out.gpuElemsFlat = gpuMem;
 
     validateMatrixAllocs(out, __func__);
     setInitialHeapFlags(out);
@@ -250,24 +250,21 @@ extern "C" DiagMatr createDiagMatr(int numQubits) {
     // validation ensures this never overflows
     qindex numElems = powerOf2(numQubits);
 
-    // initialise all CompMatr fields inline because most are const
-    DiagMatr out = {
-        .numQubits = numQubits,
-        .numElems = numElems,
-
-        // allocate flags in the heap so that struct copies are mutable
-        .isApproxUnitary       = util_allocEpsilonSensitiveHeapFlag(), // nullptr if failed
-        .isApproxHermitian     = util_allocEpsilonSensitiveHeapFlag(),
-        .isApproxNonZero       = util_allocEpsilonSensitiveHeapFlag(),
-        .isStrictlyNonNegative = cpu_allocHeapFlag(), // nullptr if failed
-        .wasGpuSynced          = cpu_allocHeapFlag(),
+    // prepare output DiagMatr (avoiding C++20 designated initialiser)
+    DiagMatr out;
+    out.numQubits = numQubits,
+    out.numElems = numElems,
 
-        // 1D CPU memory
-        .cpuElems = cpu_allocArray(numElems), // nullptr if failed
+    // attempt to allocate (uninitialised) flags in the heap so that struct copies are mutable
+    out.isApproxUnitary       = util_allocEpsilonSensitiveHeapFlag(); // nullptr if failed
+    out.isApproxHermitian     = util_allocEpsilonSensitiveHeapFlag();
+    out.isApproxNonZero       = util_allocEpsilonSensitiveHeapFlag();
+    out.isStrictlyNonNegative = cpu_allocHeapFlag(); // nullptr if failed
+    out.wasGpuSynced          = cpu_allocHeapFlag();
 
-        // 1D GPU memory
-        .gpuElems = (getQuESTEnv().isGpuAccelerated)? gpu_allocArray(numElems) : nullptr // nullptr if failed or not needed
-    };
+    // attempt to allocate 1D memory (nullptr if failed or not allocated)
+    out.cpuElems = cpu_allocArray(numElems);
+    out.gpuElems = (getQuESTEnv().isGpuAccelerated)? gpu_allocArray(numElems) : nullptr;
 
     validateMatrixAllocs(out, __func__);
     setInitialHeapFlags(out);
@@ -289,30 +286,27 @@ FullStateDiagMatr validateAndCreateCustomFullStateDiagMatr(int numQubits, int us
     qindex numElems = powerOf2(numQubits);
     qindex numElemsPerNode = numElems / (useDistrib? env.numNodes : 1); // divides evenly
 
-    FullStateDiagMatr out = {
-
-        .numQubits = numQubits,
-        .numElems = numElems,
-
-        // data deployment configuration; disable distrib if deployed to 1 node
-        .isGpuAccelerated = useGpuAccel,
-        .isMultithreaded = useMultithread,
-        .isDistributed = useDistrib && (env.numNodes > 1),
-        .numElemsPerNode = numElemsPerNode,
-
-        // allocate flags in the heap so that struct copies are mutable
-        .isApproxUnitary       = util_allocEpsilonSensitiveHeapFlag(), // nullptr if failed
-        .isApproxHermitian     = util_allocEpsilonSensitiveHeapFlag(),
-        .isApproxNonZero       = util_allocEpsilonSensitiveHeapFlag(),
-        .isStrictlyNonNegative = cpu_allocHeapFlag(), // nullptr if failed
-        .wasGpuSynced          = cpu_allocHeapFlag(),
-
-        // 1D CPU memory
-        .cpuElems = cpu_allocArray(numElemsPerNode), // nullptr if failed
-
-        // 1D GPU memory
-        .gpuElems = (useGpuAccel)? gpu_allocArray(numElemsPerNode) : nullptr, // nullptr if failed or not needed
-    };
+    // prepare output FullStateDiagMatr (avoiding C++20 designated initialiser)
+    FullStateDiagMatr out;
+    out.numQubits = numQubits;
+    out.numElems = numElems;
+
+    // bind deployments, disabling distribution if using a single MPI node
+    out.isGpuAccelerated = useGpuAccel;
+    out.isMultithreaded = useMultithread;
+    out.isDistributed = useDistrib && (env.numNodes > 1);
+    out.numElemsPerNode = numElemsPerNode;
+
+    // allocate (unitialised) flags in the heap so that struct copies are mutable
+    out.isApproxUnitary       = util_allocEpsilonSensitiveHeapFlag(); // nullptr if failed
+    out.isApproxHermitian     = util_allocEpsilonSensitiveHeapFlag();
+    out.isApproxNonZero       = util_allocEpsilonSensitiveHeapFlag();
+    out.isStrictlyNonNegative = cpu_allocHeapFlag(); // nullptr if failed
+    out.wasGpuSynced          = cpu_allocHeapFlag();
+
+    // allocate 1D memory (nullptr if failed or not allocated)
+    out.cpuElems = cpu_allocArray(numElemsPerNode);
+    out.gpuElems = (useGpuAccel)? gpu_allocArray(numElemsPerNode) : nullptr;
 
     validateMatrixAllocs(out, __func__);
     setInitialHeapFlags(out);