refactoring

libmandel/include/CpuGenerators.h

@@ -6,12 +6,12 @@
 
 namespace mnd
 {
-    template<typename T, mnd::CpuExtension ex = mnd::NONE, bool parallel = true>
+    template<typename T, mnd::HardwareFeature ex = mnd::NONE, bool parallel = true>
     class CpuGenerator;
 }
 
 
-template<typename T, mnd::CpuExtension ex, bool parallel>
+template<typename T, mnd::HardwareFeature ex, bool parallel>
 class mnd::CpuGenerator : public MandelGenerator
 {
 public:

libmandel/include/Generators.h

@@ -34,7 +34,7 @@ namespace mnd
     };
 
 
-    enum CpuExtension : int
+    enum HardwareFeature : int
     {
         NONE,
         X86_SSE2,
@@ -45,7 +45,7 @@ namespace mnd
     };
 
     std::string toString(Precision);
-    std::string toString(CpuExtension);
+    std::string toString(HardwareFeature);
 
     Real getPrecision(Precision p);
 
@@ -64,24 +64,24 @@ class mnd::MandelGenerator
 protected:
     Real precision;
     Precision type;
-    CpuExtension extension;
+    HardwareFeature extension;
 public:
     MandelGenerator(void);
     inline MandelGenerator(Precision type) :
         precision{ mnd::getPrecision(type) },
         type{ type },
-        extension{ mnd::CpuExtension::NONE }
+        extension{ mnd::HardwareFeature::NONE }
     {
     }
 
-    inline MandelGenerator(Precision type, CpuExtension extension) :
+    inline MandelGenerator(Precision type, HardwareFeature extension) :
         precision{ mnd::getPrecision(type) },
         type{ type },
         extension{ extension }
     {
     }
 
-    inline MandelGenerator(Precision type, CpuExtension extension, const Real& precision) :
+    inline MandelGenerator(Precision type, HardwareFeature extension, const Real& precision) :
         precision{ precision },
         type{ type },
         extension{ extension }
@@ -103,7 +103,7 @@ public:
 
     virtual Real getPrecision(void) const;
     virtual Precision getType(void) const;
-    virtual CpuExtension getExtension(void) const;
+    virtual HardwareFeature getExtension(void) const;
 };
 
 

libmandel/include/IterationGenerator.h

@@ -36,7 +36,7 @@ protected:
 public:
     IterationGenerator(IterationFormula z0, IterationFormula zi,
             mnd::Precision prec,
-            mnd::CpuExtension ex = mnd::CpuExtension::NONE);
+            mnd::HardwareFeature ex = mnd::HardwareFeature::NONE);
 };
 
 
@@ -45,7 +45,7 @@ class mnd::NaiveGenerator : public mnd::IterationGenerator
 public:
     NaiveGenerator(IterationFormula z0, IterationFormula zi,
             mnd::Precision prec,
-            mnd::CpuExtension ex = mnd::CpuExtension::NONE);
+            mnd::HardwareFeature ex = mnd::HardwareFeature::NONE);
 
     virtual void generate(const MandelInfo& info, float* data);
 private:
@@ -63,7 +63,7 @@ protected:
 public:
     CompiledGenerator(std::unique_ptr<ExecData> execData,
         mnd::Precision prec = mnd::Precision::DOUBLE,
-        mnd::CpuExtension ex = mnd::CpuExtension::NONE);
+        mnd::HardwareFeature ex = mnd::HardwareFeature::NONE);
     CompiledGenerator(const CompiledGenerator&) = delete;
     CompiledGenerator(CompiledGenerator&&);
     virtual ~CompiledGenerator(void);

libmandel/include/Mandel.h

@@ -72,7 +72,7 @@ class mnd::MandelContext
 private:
     friend MandelContext mnd::initializeContext(void);
 
-    using GeneratorType = std::pair<Precision, CpuExtension>;
+    using GeneratorType = std::pair<Precision, HardwareFeature>;
 
     CpuInfo cpuInfo;
     std::unique_ptr<asmjit::JitRuntime> jitRuntime;
@@ -99,7 +99,7 @@ public:
 
     asmjit::JitRuntime& getJitRuntime(void);
 
-    MandelGenerator* getCpuGenerator(mnd::Precision type, mnd::CpuExtension ex);
+    MandelGenerator* getCpuGenerator(mnd::Precision type, mnd::HardwareFeature ex);
     std::vector<GeneratorType> getSupportedTypes(void) const;
     std::vector<MandelGenerator*> getCpuGenerators(mnd::Precision prec) const;
 

libmandel/src/Generators.cpp

@@ -66,7 +66,7 @@ mnd::Precision MandelGenerator::getType(void) const
 }
 
 
-mnd::CpuExtension MandelGenerator::getExtension(void) const
+mnd::HardwareFeature MandelGenerator::getExtension(void) const
 {
     return extension;
 }
@@ -195,20 +195,20 @@ namespace mnd
     }
 
 
-    std::string toString(CpuExtension ce)
+    std::string toString(HardwareFeature ce)
     {
         switch (ce) {
-        case CpuExtension::NONE:
+        case HardwareFeature::NONE:
             return "";
-        case CpuExtension::X86_SSE2:
+        case HardwareFeature::X86_SSE2:
             return "SSE2";
-        case CpuExtension::X86_AVX:
+        case HardwareFeature::X86_AVX:
             return "AVX";
-        case CpuExtension::X86_AVX_FMA:
+        case HardwareFeature::X86_AVX_FMA:
             return "AVX2+FMA";
-        case CpuExtension::X86_AVX_512:
+        case HardwareFeature::X86_AVX_512:
             return "AVX512";
-        case CpuExtension::ARM_NEON:
+        case HardwareFeature::ARM_NEON:
             return "NEON";
         }
         return "";

libmandel/src/IterationGenerator.cpp

@@ -12,7 +12,7 @@ using mnd::IterationFormula;
 
 
 IterationGenerator::IterationGenerator(IterationFormula z0, IterationFormula zi,
-            mnd::Precision prec, mnd::CpuExtension ex) :
+            mnd::Precision prec, mnd::HardwareFeature ex) :
     mnd::MandelGenerator{ prec, ex },
     z0{ std::move(z0) },
     zi{ std::move(zi) }
@@ -21,7 +21,7 @@ IterationGenerator::IterationGenerator(IterationFormula z0, IterationFormula zi,
 
 
 NaiveGenerator::NaiveGenerator(IterationFormula z0, IterationFormula zi,
-            mnd::Precision prec, mnd::CpuExtension ex) :
+            mnd::Precision prec, mnd::HardwareFeature ex) :
     IterationGenerator{ std::move(z0), std::move(zi), prec, ex }
 {
     this->z0.optimize();
@@ -133,7 +133,7 @@ using mnd::CompiledGeneratorVec;
 
 
 CompiledGenerator::CompiledGenerator(std::unique_ptr<mnd::ExecData> execData,
-    mnd::Precision prec, mnd::CpuExtension ex) :
+    mnd::Precision prec, mnd::HardwareFeature ex) :
     MandelGenerator{ prec, ex },
     execData{ std::move(execData) }
 {
@@ -177,7 +177,7 @@ std::string CompiledGenerator::dump(void) const
 
 
 CompiledGeneratorVec::CompiledGeneratorVec(std::unique_ptr<mnd::ExecData> execData) :
-    CompiledGenerator{ std::move(execData), mnd::Precision::FLOAT, mnd::CpuExtension::X86_AVX }
+    CompiledGenerator{ std::move(execData), mnd::Precision::FLOAT, mnd::HardwareFeature::X86_AVX }
 {
 }
 

libmandel/src/Mandel.cpp

@@ -74,7 +74,7 @@ MandelContext::MandelContext(void)
     if (cpuInfo.hasAvx512()) {
         auto fl = std::make_unique<CpuGenerator<float, mnd::X86_AVX_512, true>>();
         //auto db = std::make_unique<CpuGenerator<double, mnd::X86_AVX_512, true>>();
-        cpuGenerators.insert({ std::pair{ Precision::FLOAT, CpuExtension::X86_AVX_512 }, std::move(fl) });
+        cpuGenerators.insert({ std::pair{ Precision::FLOAT, HardwareFeature::X86_AVX_512 }, std::move(fl) });
         //cpuGenerators.insert({ { Precision::DOUBLE, CpuExtension::X86_AVX_512 }, std::move(db) });
     }
 #   endif
@@ -83,10 +83,10 @@ MandelContext::MandelContext(void)
         auto db = std::make_unique<CpuGenerator<double, mnd::X86_AVX, true>>();
         auto ddb = std::make_unique<CpuGenerator<DoubleDouble, mnd::X86_AVX, true>>();
         auto tdb = std::make_unique<CpuGenerator<TripleDouble, mnd::X86_AVX, true>>();
-        cpuGenerators.insert({ std::pair{ Precision::FLOAT, CpuExtension::X86_AVX }, std::move(fl) });
-        cpuGenerators.insert({ std::pair{ Precision::DOUBLE, CpuExtension::X86_AVX }, std::move(db) });
-        cpuGenerators.insert({ std::pair{ Precision::DOUBLE_DOUBLE, CpuExtension::X86_AVX }, std::move(ddb) });
-        cpuGenerators.insert({ std::pair{ Precision::TRIPLE_DOUBLE, CpuExtension::X86_AVX }, std::move(tdb) });
+        cpuGenerators.insert({ std::pair{ Precision::FLOAT, HardwareFeature::X86_AVX }, std::move(fl) });
+        cpuGenerators.insert({ std::pair{ Precision::DOUBLE, HardwareFeature::X86_AVX }, std::move(db) });
+        cpuGenerators.insert({ std::pair{ Precision::DOUBLE_DOUBLE, HardwareFeature::X86_AVX }, std::move(ddb) });
+        cpuGenerators.insert({ std::pair{ Precision::TRIPLE_DOUBLE, HardwareFeature::X86_AVX }, std::move(tdb) });
     }
     if (cpuInfo.hasAvx2() && cpuInfo.hasFma()) {
         auto favxfma = std::make_unique<CpuGenerator<float, mnd::X86_AVX_FMA, true>>();
@@ -94,17 +94,17 @@ MandelContext::MandelContext(void)
         auto ddavxfma = std::make_unique<CpuGenerator<DoubleDouble, mnd::X86_AVX_FMA, true>>();
         auto qdavxfma = std::make_unique<CpuGenerator<QuadDouble, mnd::X86_AVX_FMA, true>>();
         auto hdavxfma = std::make_unique<CpuGenerator<HexDouble, mnd::X86_AVX_FMA, true>>();
-        cpuGenerators.insert({ std::pair{ Precision::FLOAT, CpuExtension::X86_AVX_FMA }, std::move(favxfma) });
-        cpuGenerators.insert({ std::pair{ Precision::DOUBLE, CpuExtension::X86_AVX_FMA }, std::move(davxfma) });
-        cpuGenerators.insert({ std::pair{ Precision::DOUBLE_DOUBLE, CpuExtension::X86_AVX_FMA }, std::move(ddavxfma) });
-        cpuGenerators.insert({ std::pair{ Precision::QUAD_DOUBLE, CpuExtension::X86_AVX_FMA }, std::move(qdavxfma) });
-        cpuGenerators.insert({ std::pair{ Precision::HEX_DOUBLE, CpuExtension::X86_AVX_FMA }, std::move(hdavxfma) });
+        cpuGenerators.insert({ std::pair{ Precision::FLOAT, HardwareFeature::X86_AVX_FMA }, std::move(favxfma) });
+        cpuGenerators.insert({ std::pair{ Precision::DOUBLE, HardwareFeature::X86_AVX_FMA }, std::move(davxfma) });
+        cpuGenerators.insert({ std::pair{ Precision::DOUBLE_DOUBLE, HardwareFeature::X86_AVX_FMA }, std::move(ddavxfma) });
+        cpuGenerators.insert({ std::pair{ Precision::QUAD_DOUBLE, HardwareFeature::X86_AVX_FMA }, std::move(qdavxfma) });
+        cpuGenerators.insert({ std::pair{ Precision::HEX_DOUBLE, HardwareFeature::X86_AVX_FMA }, std::move(hdavxfma) });
     }
     if (cpuInfo.hasSse2()) {
         auto fl = std::make_unique<CpuGenerator<float, mnd::X86_SSE2, true>>();
         auto db = std::make_unique<CpuGenerator<double, mnd::X86_SSE2, true>>();
-        cpuGenerators.insert({ std::pair{ Precision::FLOAT, CpuExtension::X86_SSE2 }, std::move(fl) });
-        cpuGenerators.insert({ std::pair{ Precision::DOUBLE, CpuExtension::X86_SSE2 }, std::move(db) });
+        cpuGenerators.insert({ std::pair{ Precision::FLOAT, HardwareFeature::X86_SSE2 }, std::move(fl) });
+        cpuGenerators.insert({ std::pair{ Precision::DOUBLE, HardwareFeature::X86_SSE2 }, std::move(db) });
     }
 #elif defined(__arm__) || defined(__aarch64__) || defined(_M_ARM) 
     if (cpuInfo.hasNeon()) {
@@ -119,22 +119,22 @@ MandelContext::MandelContext(void)
     {
         auto fl = std::make_unique<CpuGenerator<float, mnd::NONE, true>>();
         auto db = std::make_unique<CpuGenerator<double, mnd::NONE, true>>();
-        cpuGenerators.insert({ std::pair{ Precision::FLOAT, CpuExtension::NONE }, std::move(fl) });
-        cpuGenerators.insert({ std::pair{ Precision::DOUBLE, CpuExtension::NONE }, std::move(db) });
+        cpuGenerators.insert({ std::pair{ Precision::FLOAT, HardwareFeature::NONE }, std::move(fl) });
+        cpuGenerators.insert({ std::pair{ Precision::DOUBLE, HardwareFeature::NONE }, std::move(db) });
 
         auto fx64 = std::make_unique<CpuGenerator<Fixed64, mnd::NONE, true>>();
         auto fx128 = std::make_unique<CpuGenerator<Fixed128, mnd::NONE, true>>();
-        cpuGenerators.insert({ std::pair{ Precision::FIXED64, CpuExtension::NONE }, std::move(fx64) });
-        cpuGenerators.insert({ std::pair{ Precision::FIXED128, CpuExtension::NONE }, std::move(fx128) });
+        cpuGenerators.insert({ std::pair{ Precision::FIXED64, HardwareFeature::NONE }, std::move(fx64) });
+        cpuGenerators.insert({ std::pair{ Precision::FIXED128, HardwareFeature::NONE }, std::move(fx128) });
     }
 
 #ifdef WITH_BOOST
     auto quad = std::make_unique<CpuGenerator<Float128, mnd::NONE, true>>();
     auto oct = std::make_unique<CpuGenerator<Float256, mnd::NONE, true>>();
     auto f512 = std::make_unique<CpuGenerator<Float512, mnd::NONE, true>>();
-    cpuGenerators.insert({ std::pair{ Precision::FLOAT128, CpuExtension::NONE }, std::move(quad) });
-    cpuGenerators.insert({ std::pair{ Precision::FLOAT256, CpuExtension::NONE }, std::move(oct) });
-    cpuGenerators.insert({ std::pair{ Precision::FLOAT512, CpuExtension::NONE }, std::move(f512) });
+    cpuGenerators.insert({ std::pair{ Precision::FLOAT128, HardwareFeature::NONE }, std::move(quad) });
+    cpuGenerators.insert({ std::pair{ Precision::FLOAT256, HardwareFeature::NONE }, std::move(oct) });
+    cpuGenerators.insert({ std::pair{ Precision::FLOAT512, HardwareFeature::NONE }, std::move(f512) });
 #endif // WITH_BOOST
 
     auto dd = std::make_unique<CpuGenerator<DoubleDouble, mnd::NONE, true>>();
@@ -142,15 +142,15 @@ MandelContext::MandelContext(void)
     auto qd = std::make_unique<CpuGenerator<QuadDouble, mnd::NONE, true>>();
     auto hd = std::make_unique<CpuGenerator<HexDouble, mnd::NONE, true>>();
     auto od = std::make_unique<CpuGenerator<OctaDouble, mnd::NONE, true>>();
-    cpuGenerators.insert({ std::pair{ Precision::DOUBLE_DOUBLE, CpuExtension::NONE }, std::move(dd) });
-    cpuGenerators.insert({ std::pair{ Precision::TRIPLE_DOUBLE, CpuExtension::NONE }, std::move(td) });
-    cpuGenerators.insert({ std::pair{ Precision::QUAD_DOUBLE, CpuExtension::NONE }, std::move(qd) });
-    cpuGenerators.insert({ std::pair{ Precision::HEX_DOUBLE, CpuExtension::NONE }, std::move(hd) });
-    cpuGenerators.insert({ std::pair{ Precision::OCTA_DOUBLE, CpuExtension::NONE }, std::move(od) });
+    cpuGenerators.insert({ std::pair{ Precision::DOUBLE_DOUBLE, HardwareFeature::NONE }, std::move(dd) });
+    cpuGenerators.insert({ std::pair{ Precision::TRIPLE_DOUBLE, HardwareFeature::NONE }, std::move(td) });
+    cpuGenerators.insert({ std::pair{ Precision::QUAD_DOUBLE, HardwareFeature::NONE }, std::move(qd) });
+    cpuGenerators.insert({ std::pair{ Precision::HEX_DOUBLE, HardwareFeature::NONE }, std::move(hd) });
+    cpuGenerators.insert({ std::pair{ Precision::OCTA_DOUBLE, HardwareFeature::NONE }, std::move(od) });
 
 
     auto fix512 = std::make_unique<CpuGenerator<Fixed512, mnd::NONE, true>>();
-    cpuGenerators.insert({ std::pair{ Precision::FIXED512, CpuExtension::NONE }, std::move(fix512) });
+    cpuGenerators.insert({ std::pair{ Precision::FIXED512, HardwareFeature::NONE }, std::move(fix512) });
 
     devices = createDevices();
 
@@ -178,7 +178,7 @@ std::unique_ptr<mnd::AdaptiveGenerator> MandelContext::createAdaptiveGenerator(v
     for (auto type : types) {
         MandelGenerator* chosenGen = nullptr;
         auto generators = getCpuGenerators(type);
-        CpuExtension ex = CpuExtension::NONE;
+        HardwareFeature ex = HardwareFeature::NONE;
         for (auto* generator : generators) {
             if (generator->getExtension() >= ex) {
                 ex = generator->getExtension();
@@ -353,7 +353,7 @@ asmjit::JitRuntime& MandelContext::getJitRuntime(void)
 }
 
 
-MandelGenerator* MandelContext::getCpuGenerator(mnd::Precision type, mnd::CpuExtension ex)
+MandelGenerator* MandelContext::getCpuGenerator(mnd::Precision type, mnd::HardwareFeature ex)
 {
     auto it = cpuGenerators.find({ type, ex });
     if (it != cpuGenerators.end())

src/EscapeTimeVisualWidget.cpp

@@ -171,7 +171,7 @@ bool RenderTextureProgram::link(void)
     gradLoc = this->uniformLocation("gradient");
     gradientScalerLoc = this->uniformLocation("gradientScaler");
     maxIterationsLoc = this->uniformLocation("maxIterations");
-
+    return bound;
 }
 
 EscapeTimeVisualWidget::EscapeTimeVisualWidget(QWidget* parent) :

src/choosegenerators.cpp

@@ -228,7 +228,7 @@ ChooseGenerators::ChooseGenerators(mnd::MandelContext& mndCtxt, mnd::GeneratorCo
 
     for (auto& gen : gc.cpuGenerators) {
         const mnd::Precision p = gen->getType();
-        const mnd::CpuExtension ce = gen->getExtension();
+        const mnd::HardwareFeature ce = gen->getExtension();
         std::string typeName = mnd::toString(p) + " " + mnd::toString(ce);
         generators.insert({ QString::fromStdString(typeName), gen.get() });
     }
@@ -236,7 +236,7 @@ ChooseGenerators::ChooseGenerators(mnd::MandelContext& mndCtxt, mnd::GeneratorCo
 
     for (auto& gen : gc.clGenerators) {
         const mnd::Precision p = gen->getType();
-        const mnd::CpuExtension ce = gen->getExtension();
+        const mnd::HardwareFeature ce = gen->getExtension();
         mnd::MandelDevice* dev = gen->getDevice();
         std::string devString = dev != nullptr ? dev->getName() : "";
         std::string typeName = mnd::toString(p) + " " + mnd::toString(ce) + " [" + devString + "]";
@@ -293,7 +293,7 @@ void ChooseGenerators::initializeTables(void)
         ui->generatorTable->setItem(rowCount, 1, new QTableWidgetItem);
         mnd::MandelGenerator& gene = *it->second;
         mnd::Precision p = gene.getType();
-        mnd::CpuExtension ex = gene.getExtension();
+        mnd::HardwareFeature ex = gene.getExtension();
         mnd::MandelDevice* dev = gene.getDevice();
 
         std::string desc = mnd::toString(p) + " " + mnd::toString(ex);