std::pair<int, int> Network::checkOnlineMags(const QUrl & url) { int lowestAvailableMag = NUM_MAG_DATASETS; int highestAvailableMag = 0; int maxMagCount = int_log(NUM_MAG_DATASETS) + 1; QProgressDialog progress("Network Operation…", "Abort", 0, 100, state->mainWindow); progress.setModal(true); std::vector<qint64> bytesReceivedAll(maxMagCount); std::vector<qint64> bytesTotalAll(maxMagCount); std::vector<std::unique_ptr<QNetworkReply>> replies(maxMagCount); QTimer::singleShot(400, &progress, &QProgressDialog::show); QEventLoop pause; for (int currMag = 1; currMag <= NUM_MAG_DATASETS; currMag *= 2) { QUrl magUrl = url; magUrl.setPath(QString("%1/mag%2/knossos.conf").arg(url.path()).arg(currMag)); auto * replyPtr = manager.get(QNetworkRequest{magUrl}); replies[int_log(currMag)] = decltype(replies)::value_type{replyPtr}; QObject::connect(replyPtr, &QNetworkReply::finished, [magUrl, &pause, &maxMagCount, currMag, replyPtr, &lowestAvailableMag, &highestAvailableMag]() { auto & reply = *replyPtr; if (reply.error() == QNetworkReply::NoError) { lowestAvailableMag = std::min(lowestAvailableMag, currMag); highestAvailableMag = std::max(highestAvailableMag, currMag); } if (--maxMagCount == 0) { pause.exit(); } }); auto processProgress = [&progress, currMag, &bytesReceivedAll, &bytesTotalAll](qint64 bytesReceived, qint64 bytesTotal){ bytesReceivedAll[int_log(currMag)] = bytesReceived; bytesTotalAll[int_log(currMag)] = bytesTotal; const auto received = std::accumulate(std::begin(bytesReceivedAll), std::end(bytesReceivedAll), qint64{0}); const auto total = std::accumulate(std::begin(bytesTotalAll), std::end(bytesTotalAll), qint64{0}); progress.setRange(0, total); progress.setValue(received); }; QObject::connect(replyPtr, &QNetworkReply::downloadProgress, processProgress); QObject::connect(replyPtr, &QNetworkReply::uploadProgress, processProgress); QObject::connect(&progress, &QProgressDialog::canceled, replyPtr, &QNetworkReply::abort); } pause.exec(); if (lowestAvailableMag > highestAvailableMag) { throw std::runtime_error{"no mags detected"}; } return {lowestAvailableMag, highestAvailableMag}; }
UL_int DigitalSequence_advanced::get_log_BufferLenForBase(UL_int base) { if((base>= 2)&&(base<=10)) return int_log(get_BufferLenForBase(base),base); if(base<=MAX_BUFFER_LEN) return 1; return 0; }
void DatasetPropertyWidget::loadSettings() { QSettings settings; settings.beginGroup(DATASET_WIDGET); path->clear(); path->insertItems(0, settings.value(DATASET_MRU).toStringList()); if (state->M == 0) {//M is invalid state->M = settings.value(DATASET_M, 3).toInt(); } settings.endGroup(); supercubeEdgeSpin->setValue(state->M); supercubeEdgeSpinValueChanged(state->M);//refill label //settings depending on M state->cubeSetElements = state->M * state->M * state->M; state->cubeSetBytes = state->cubeSetElements * state->cubeBytes; for(uint i = 0; i < state->viewerState->numberViewports; i++) { state->viewerState->vpConfigs[i].texture.texUnitsPerDataPx /= static_cast<float>(state->magnification); state->viewerState->vpConfigs[i].texture.usedTexLengthDc = state->M; } if(state->M * state->cubeEdgeLength >= TEXTURE_EDGE_LEN) { qDebug() << "Please choose smaller values for M or N. Your choice exceeds the KNOSSOS texture size!"; throw std::runtime_error("Please choose smaller values for M or N. Your choice exceeds the KNOSSOS texture size!"); } // We're not doing stuff in parallel, yet. So we skip the locking // part. // This *10 thing is completely arbitrary. The larger the table size, // the lower the chance of getting collisions and the better the loading // order will be respected. *10 doesn't seem to have much of an effect // on performance but we should try to find the optimal value some day. // Btw: A more clever implementation would be to use an array exactly the // size of the supercube and index using the modulo operator. // sadly, that realization came rather late. ;) // creating the hashtables is cheap, keeping the datacubes is // memory expensive.. for(int i = 0; i <= NUM_MAG_DATASETS; i = i * 2) { state->Dc2Pointer[int_log(i)] = Hashtable::ht_new(state->cubeSetElements * 10); state->Oc2Pointer[int_log(i)] = Hashtable::ht_new(state->cubeSetElements * 10); if(i == 0) i = 1; } }
std::pair<bool, char *> getRawCube(const Coordinate & pos) { const auto posDc = pos.cube(state->cubeEdgeLength, state->magnification); state->protectCube2Pointer.lock(); auto rawcube = Coordinate2BytePtr_hash_get_or_fail(state->Oc2Pointer[int_log(state->magnification)], posDc); state->protectCube2Pointer.unlock(); return std::make_pair(rawcube != nullptr, rawcube); }
void ZoomWidget::reinitializeOrthoZoomWidgets() { const auto mags = int_log(state->viewer->highestMag()) - int_log(state->viewer->lowestMag()) + 1; const auto interval = 50; zoomStep = std::pow(2, 1./interval); int max_value = std::ceil(std::log(state->viewer->highestScreenPxXPerDataPx() / state->viewer->lowestScreenPxXPerDataPx()) / std::log(zoomStep)); orthoZoomSlider.numTicks = mags > 1 ? mags : 0; orthoZoomSlider.highestMag = state->viewer->highestMag(); const auto orthoZoomSliderBlock = orthoZoomSlider.blockSignals(true); orthoZoomSlider.setRange(0, max_value); orthoZoomSlider.setTickInterval(interval); updateOrthogonalZoomSlider(); orthoZoomSlider.blockSignals(orthoZoomSliderBlock); const auto orthoZoomSpinBoxBlock = orthoZoomSpinBox.blockSignals(true); orthoZoomSpinBox.setMinimum(100 * (state->viewer->lowestScreenPxXPerDataPx(false) / state->viewer->lowestScreenPxXPerDataPx(false))); orthoZoomSpinBox.setMaximum(100 * (state->viewer->highestScreenPxXPerDataPx(false) / state->viewer->lowestScreenPxXPerDataPx(false))); updateOrthogonalZoomSpinBox(); orthoZoomSlider.blockSignals(orthoZoomSpinBoxBlock); }
hashtable *hashtable_alloc(size_t capacity, uint32_t (*hash) (const void *), int (*eq) (const void *, const void *)) { hashtable *ht = malloc(sizeof(hashtable)); assert(ht); /* capacity must be power of 2 */ ht->size = 0; ht->capacity = int_pow2(int_log(2, 2*capacity)); ht->table = malloc(ht->capacity * sizeof(hash_elem *)); assert(ht->table); memset(ht->table, 0, ht->capacity * sizeof(hash_elem *)); ht->hash = hash; ht->eq = eq; return ht; }
/* * Builds the btree to index the map. */ int dm_table_complete(struct dm_table *t) { int r = 0; unsigned int leaf_nodes; check_for_valid_limits(&t->limits); /* how many indexes will the btree have ? */ leaf_nodes = dm_div_up(t->num_targets, KEYS_PER_NODE); t->depth = 1 + int_log(leaf_nodes, CHILDREN_PER_NODE); /* leaf layer has already been set up */ t->counts[t->depth - 1] = leaf_nodes; t->index[t->depth - 1] = t->highs; if (t->depth >= 2) r = setup_indexes(t); return r; }
constexpr std::size_t int_log(const std::size_t val, const std::size_t base = 2, const std::size_t res = 0) { return val < base ? res : int_log(val/base, base, res+1); }
constexpr T int_log(const T & val, const T & base = 2, const T & res = 0) { return val < base ? res : int_log(val/base, base, res+1); }