#include "choosegenerators.h" #include "ui_choosegenerators.h" #include "Hardware.h" #include #include #include #include mnd::MandelViewport Benchmarker::benchViewport(void) { return mnd::MandelViewport{ -1.250000598933854152929, 0.0001879894057291665530, 0.0000003839916666666565, 0.0000003839916666666565 }; } const std::vector Benchmarker::benches { mnd::MandelInfo{ benchViewport(), 25, 25, 15, false }, mnd::MandelInfo{ benchViewport(), 25, 25, 25, false }, mnd::MandelInfo{ benchViewport(), 25, 25, 75, false }, mnd::MandelInfo{ benchViewport(), 25, 25, 125, false }, mnd::MandelInfo{ benchViewport(), 25, 25, 250, false }, mnd::MandelInfo{ benchViewport(), 50, 25, 250, false }, mnd::MandelInfo{ benchViewport(), 50, 50, 250, false }, mnd::MandelInfo{ benchViewport(), 50, 50, 500, false }, mnd::MandelInfo{ benchViewport(), 50, 100, 500, false }, mnd::MandelInfo{ benchViewport(), 100, 100, 500, false }, mnd::MandelInfo{ benchViewport(), 100, 100, 1000, false }, mnd::MandelInfo{ benchViewport(), 100, 200, 1000, false }, mnd::MandelInfo{ benchViewport(), 200, 200, 1000, false }, mnd::MandelInfo{ benchViewport(), 200, 200, 2000, false }, mnd::MandelInfo{ benchViewport(), 200, 400, 2000, false }, mnd::MandelInfo{ benchViewport(), 400, 400, 2000, false }, mnd::MandelInfo{ benchViewport(), 400, 400, 4000, false }, mnd::MandelInfo{ benchViewport(), 400, 800, 4000, false }, mnd::MandelInfo{ benchViewport(), 800, 800, 4000, false }, mnd::MandelInfo{ benchViewport(), 800, 800, 8000, false }, mnd::MandelInfo{ benchViewport(), 800, 800, 16000, false }, mnd::MandelInfo{ benchViewport(), 800, 1600, 16000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 16000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 32000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 64000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 128000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 256000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 512000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 1024000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 4096000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 8192000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 16384000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 32768000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 65536000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 131072000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 262144000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 524288000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 1048576000, false }, mnd::MandelInfo{ benchViewport(), 1600, 1600, 2097152000, false }, }; Benchmarker::~Benchmarker(void) { } std::pair Benchmarker::measureMips(const std::function*()>& bench) const { using namespace std::chrono; auto before = high_resolution_clock::now(); auto* bitmap = bench(); auto after = high_resolution_clock::now(); long long sum = 0; for (int i = 0; i < bitmap->width * bitmap->height; i++) { sum += static_cast(std::floor(bitmap->pixels[size_t(i)])); } return std::make_pair(sum, duration_cast(after - before)); } double Benchmarker::benchmarkResult(mnd::Generator& mg) const { size_t testIndex = 0; for (size_t i = 0; i < benches.size(); i++) { const mnd::MandelInfo& mi = benches[i]; Bitmap bmp(mi.bWidth, mi.bHeight); auto [iters, time] = measureMips([&mg, &mi, &bmp]() { mg.generate(mi, bmp.pixels.get()); return &bmp; }); if (time > std::chrono::milliseconds(500)) { testIndex = i + 2; //printf("testing index %d\n", testIndex); fflush(stdout); break; } else if (time < std::chrono::milliseconds(10)) { i += 3; } } const mnd::MandelInfo& mi = benches[(testIndex >= benches.size()) ? (benches.size() - 1) : testIndex]; Bitmap bmp(mi.bWidth, mi.bHeight); auto [iters, time] = measureMips([&mg, &mi, &bmp]() { mg.generate(mi, bmp.pixels.get()); return &bmp; }); return double(iters) / time.count() * 1000; } void Benchmarker::run(void) { double result = benchmarkResult(generator); emit finished(row, percentage, result); } ChooseGenerators::ChooseGenerators(mnd::MandelContext& mndCtxt, QWidget *parent) : QDialog{ parent }, ui{ std::make_unique() }, mndCtxt{ mndCtxt }, tableContent{} { ui->setupUi(this); ui->progressBar->setRange(0, 1000); benchmarker.setMaxThreadCount(1); QRegExp floatingpoint{ "^[-+]?(\\d*\\.?\\d+|\\d+\\.?\\d*)([eE][-+]\\d+)?$" }; floatValidator = std::make_unique(floatingpoint, this); for (auto genType : mndCtxt.getSupportedTypes()) { const std::string& typeName = mnd::getGeneratorName(genType); generators.insert({ QString::fromStdString(typeName), mndCtxt.getCpuGenerator(genType) }); } for (auto& device : mndCtxt.getDevices()) { for (auto genType : device.getSupportedTypes()) { const std::string& typeName = mnd::getGeneratorName(genType) + " [" + device.getName() + "]"; generators.insert({ QString::fromStdString(typeName), device.getGenerator(genType) }); } } /*generators = std::map { { "float", mndCtxt.getCpuGenerator(mnd::GeneratorType::FLOAT) }, { "double", mndCtxt.getCpuGenerator(mnd::GeneratorType::DOUBLE) }, { "double double", mndCtxt.getCpuGenerator(mnd::GeneratorType::DOUBLE_DOUBLE) }, { "quad double", mndCtxt.getCpuGenerator(mnd::GeneratorType::QUAD_DOUBLE) }, { "float256", mndCtxt.getCpuGenerator(mnd::GeneratorType::FLOAT256) }, { "fixed512", mndCtxt.getCpuGenerator(mnd::GeneratorType::FIXED512) }, }; if (mndCtxt.getCpuInfo().hasSse2()) { generators.insert({ "float SSE2", mndCtxt.getCpuGenerator(mnd::GeneratorType::FLOAT_SSE2) }); generators.insert({ "double SSE2", mndCtxt.getCpuGenerator(mnd::GeneratorType::DOUBLE_SSE2) }); } if (mndCtxt.getCpuInfo().hasAvx()) { generators.insert({ "float AVX", mndCtxt.getCpuGenerator(mnd::GeneratorType::FLOAT_AVX) }); generators.insert({ "double AVX", mndCtxt.getCpuGenerator(mnd::GeneratorType::DOUBLE_AVX) }); if (mndCtxt.getCpuInfo().hasFma()) { generators.insert({ "double double AVX", mndCtxt.getCpuGenerator(mnd::GeneratorType::DOUBLE_DOUBLE_AVX) }); } } if (mndCtxt.getCpuInfo().hasNeon()) { generators.insert({ "float Neon", mndCtxt.getCpuGenerator(mnd::GeneratorType::FLOAT_NEON) }); generators.insert({ "double Neon", mndCtxt.getCpuGenerator(mnd::GeneratorType::DOUBLE_NEON) }); } for (auto& device : mndCtxt.getDevices()) { if (mnd::Generator* gen; (gen = device.getGenerator(mnd::GeneratorType::FLOAT))) { generators.insert({ QString("float ") + QString::fromStdString(device.getName()), gen }); } if (mnd::Generator* gen; (gen = device.getGenerator(mnd::GeneratorType::DOUBLE))) { generators.insert({ QString("double ") + QString::fromStdString(device.getName()), gen }); } if (mnd::Generator* gen; (gen = device.getGenerator(mnd::GeneratorType::DOUBLE_DOUBLE))) { generators.insert({ QString("double double ") + QString::fromStdString(device.getName()), gen }); } }*/ auto& defGen = mndCtxt.getDefaultGenerator(); for (auto it = defGen.getGenerators().rbegin(); it != defGen.getGenerators().rend(); it++) { auto& [prec, gen] = *it; ui->table->insertRow(0); QLineEdit* le = createFloatText(); QComboBox* comboBox = createComboBox(); le->setSizePolicy(QSizePolicy::Policy::Preferred, QSizePolicy::Policy::Preferred); comboBox->setSizePolicy(QSizePolicy::Policy::Preferred, QSizePolicy::Policy::Preferred); ui->table->setCellWidget(0, 0, le); ui->table->setCellWidget(0, 1, comboBox); tableContent.push_back({ le, comboBox }); for (auto [n, g] : generators) { if (gen == g) { comboBox->setCurrentText(n); } } le->setText(QString::fromStdString(mnd::toLegibleString(prec))); comboBox->adjustSize(); le->adjustSize(); } ui->table->resizeColumnsToContents(); std::vector generatorTypes = mndCtxt.getSupportedTypes(); for (size_t i = 0; i < generatorTypes.size(); i++) { int rowCount = ui->generatorTable->rowCount(); ui->generatorTable->insertRow(rowCount); ui->generatorTable->setItem(rowCount, 0, new QTableWidgetItem); ui->generatorTable->setItem(rowCount, 1, new QTableWidgetItem); const std::string& genName = mnd::getGeneratorName(generatorTypes[i]); const mnd::Real& prec = mndCtxt.getCpuGenerator(generatorTypes[i])->getPrecision(); ui->generatorTable->item(rowCount, 0)->setText(QString::fromStdString(genName)); ui->generatorTable->item(rowCount, 1)->setText(QString::fromStdString(mnd::toLegibleString(prec))); actualGenerators.push_back(mndCtxt.getCpuGenerator(generatorTypes[i])); } for (auto& device : mndCtxt.getDevices()) { std::vector generatorTypes = device.getSupportedTypes(); for (size_t i = 0; i < generatorTypes.size(); i++) { int rowCount = ui->generatorTable->rowCount(); ui->generatorTable->insertRow(rowCount); ui->generatorTable->setItem(rowCount, 0, new QTableWidgetItem); ui->generatorTable->setItem(rowCount, 1, new QTableWidgetItem); const std::string& genName = mnd::getGeneratorName(generatorTypes[i]) + " [" + device.getName() + "]"; const mnd::Real& prec = device.getGenerator(generatorTypes[i])->getPrecision(); ui->generatorTable->item(rowCount, 0)->setText(QString::fromStdString(genName)); ui->generatorTable->item(rowCount, 1)->setText(QString::fromStdString(mnd::toLegibleString(prec))); actualGenerators.push_back(device.getGenerator(generatorTypes[i])); } } //ui->addRow->setIcon(ui->addRow->style()->standardIcon(QStyle::SP_)); //ui->moveRowUp->setIcon(ui->moveRowUp->style()->standardIcon(QStyle::SP_ArrowUp)); //ui->moveRowDown->setIcon(ui->moveRowDown->style()->standardIcon(QStyle::SP_ArrowDown)); } ChooseGenerators::~ChooseGenerators() { } QComboBox* ChooseGenerators::createComboBox(void) { QComboBox* qcb = new QComboBox(ui->table); for (auto [name, type] : generators) { qcb->addItem(name); } return qcb; } QLineEdit* ChooseGenerators::createFloatText(void) { QLineEdit* le = new QLineEdit(ui->table); le->setValidator(floatValidator.get()); return le; } void ChooseGenerators::setBenchmarkResult(int row, float percentage, double result) { this->ui->generatorTable->setItem(row, 2, new QTableWidgetItem); this->ui->generatorTable->item(row, 2)->setText(QString::number(result)); ui->progressBar->setValue(int(percentage * 10.0f)); } void ChooseGenerators::on_buttonBox_accepted() { if (!createdGenerator) createdGenerator = std::make_unique(); createdGenerator->clear(); try { for (size_t i = 0; i < tableContent.size(); i++) { QString precString = tableContent.at(i).first->text(); QString genString = tableContent.at(i).second->currentText(); mnd::Real precision = mnd::Real(precString.toStdString().c_str()); mnd::Generator* generator = generators.at(genString); if (generator) createdGenerator->addGenerator(precision, *generator); } } catch(...) { // TODO createdGenerator = nullptr; } } void ChooseGenerators::on_run_clicked() { ui->progressBar->setValue(0); for (int i = 0; i < ui->generatorTable->rowCount(); i++) { mnd::Generator* gen = actualGenerators.at(i); if (gen != nullptr) { Benchmarker* bench = new Benchmarker(mndCtxt, *gen, i, 100.0f * (i + 1) / ui->generatorTable->rowCount()); QObject::connect(bench, &Benchmarker::finished, this, &ChooseGenerators::setBenchmarkResult); benchmarker.start(bench); } } } void ChooseGenerators::on_generatorTable_cellDoubleClicked(int row, int column) { if (column == 2) { QMessageBox msgBox{ this }; msgBox.setText("Would you like to benchmark this generator?"); msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No); int response = msgBox.exec(); if (response == QMessageBox::Yes) { mnd::Generator* gen = actualGenerators.at(row); if (gen != nullptr) { ui->progressBar->setValue(0); Benchmarker* bench = new Benchmarker(mndCtxt, *gen, row, 100.0f); QObject::connect(bench, &Benchmarker::finished, this, &ChooseGenerators::setBenchmarkResult); benchmarker.start(bench); } } } }