/*! \brief Calculate a scale division \param x1 First interval limit \param x2 Second interval limit \param maxMajSteps Maximum for the number of major steps \param maxMinSteps Maximum number of minor steps \param stepSize Step size. If stepSize == 0, the scaleEngine calculates one. \sa QwtScaleEngine::stepSize, QwtLog10ScaleEngine::subDivide */ QwtScaleDiv QwtLog10ScaleEngine::divideScale(double x1, double x2, int maxMajSteps, int maxMinSteps, double stepSize) const { QwtDoubleInterval interval = QwtDoubleInterval(x1, x2).normalized(); interval = interval.limited(LOG_MIN, LOG_MAX); if (interval.width() <= 0 ) return QwtScaleDiv(); if (interval.maxValue() / interval.minValue() < 10.0) { // scale width is less than one decade -> build linear scale QwtLinearScaleEngine linearScaler; linearScaler.setAttributes(attributes()); linearScaler.setReference(reference()); linearScaler.setMargins(loMargin(), hiMargin()); return linearScaler.divideScale(x1, x2, maxMajSteps, maxMinSteps, stepSize); } stepSize = qwtAbs(stepSize); if ( stepSize == 0.0 ) { if ( maxMajSteps < 1 ) maxMajSteps = 1; stepSize = divideInterval(log10(interval).width(), maxMajSteps); if ( stepSize < 1.0 ) stepSize = 1.0; // major step must be >= 1 decade } QwtScaleDiv scaleDiv; if ( stepSize != 0.0 ) { QwtValueList ticks[QwtScaleDiv::NTickTypes]; buildTicks(interval, stepSize, maxMinSteps, ticks); scaleDiv = QwtScaleDiv(interval, ticks); } if ( x1 > x2 ) scaleDiv.invert(); return scaleDiv; }
void labellingErrors(CArrayF& activs, CArrayI& seqLengths, int idx, CArrayI& labellings, ArrayI& lev) { nLabelsInclBlank_ = activs.dim(2); blankIdx_ = nLabelsInclBlank_ - 1; T_ = seqLengths(idx); int len = calcLen(labellings, idx); std::vector<int> labelling = label(activs, idx); std::vector<int> reference(len); for(int i = 0; i < len; ++i) { reference[i] = labellings(idx, i); } int dist = levenshteinDist(labelling, reference); lev(idx) = dist; }
void Cmvmi::execREAD_CONFIG_REQ(Signal* signal) { jamEntry(); const ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtr(); Uint32 ref = req->senderRef; Uint32 senderData = req->senderData; const ndb_mgm_configuration_iterator * p = m_ctx.m_config.getOwnConfigIterator(); ndbrequire(p != 0); Uint64 page_buffer = 64*1024*1024; ndb_mgm_get_int64_parameter(p, CFG_DB_DISK_PAGE_BUFFER_MEMORY, &page_buffer); Uint32 pages = 0; pages += page_buffer / GLOBAL_PAGE_SIZE; // in pages pages += LCP_RESTORE_BUFFER; m_global_page_pool.setSize(pages + 64, true); Uint64 shared_mem = 8*1024*1024; ndb_mgm_get_int64_parameter(p, CFG_DB_SGA, &shared_mem); shared_mem /= GLOBAL_PAGE_SIZE; if (shared_mem) { Resource_limit rl; rl.m_min = 0; rl.m_max = shared_mem; rl.m_resource_id = 0; m_ctx.m_mm.set_resource_limit(rl); } ndbrequire(m_ctx.m_mm.init()); { void* ptr = m_ctx.m_mm.get_memroot(); m_shared_page_pool.set((GlobalPage*)ptr, ~0); } ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend(); conf->senderRef = reference(); conf->senderData = senderData; sendSignal(ref, GSN_READ_CONFIG_CONF, signal, ReadConfigConf::SignalLength, JBB); }
int main(int argc, char *argv[]) { myName = argv[0]; if (argc <= 1) { printUsage(); exit(-1); } if (strcmp("diff", argv[1]) == 0 || strcmp("diffSigned", argv[1]) == 0) { diffFlow(argc, argv); } else if (strcmp("ref", argv[1]) == 0) { reference().save("reference.png"); } else { colourizeFlow(argc, argv); } }
void testAddHeaderAndTagToFile(const char* inputName, const char* outputName) { SamFile inSam, outSam; assert(inSam.OpenForRead(inputName)); assert(outSam.OpenForWrite(outputName)); // Read the SAM Header. SamFileHeader samHeader; assert(inSam.ReadHeader(samHeader)); // Add a header line. assert(samHeader.addHeaderLine("@RG\tID:myID\tSM:mySM") == false); assert(samHeader.addHeaderLine("@RG\tID:myID3\tSM:mySM") == true); // Write Header assert(outSam.WriteHeader(samHeader)); SamRecord samRecord; assert(inSam.ReadRecord(samHeader, samRecord)); // validateRead1(samRecord); // Add two tags. assert(samRecord.addIntTag("XA", 123)); assert(samRecord.addIntTag("XA", 456)); assert(samRecord.addTag("RR", 'Z', "myID1")); assert(samRecord.addTag("RR", 'Z', "myID2")); // Write as Sam. assert(outSam.WriteRecord(samHeader, samRecord)); // TODO, add test to verify it was written correctly. // Read a couple of records to make sure it properly can read them even // if they are bigger than the original. assert(inSam.ReadRecord(samHeader, samRecord)); assert(inSam.ReadRecord(samHeader, samRecord)); // Check the MD tag, which requires the reference. GenomeSequence reference("testFiles/chr1_partial.fa"); assert(SamTags::isMDTagCorrect(samRecord, reference) == false); String newMDTag; SamTags::createMDTag(newMDTag, samRecord, reference); assert(newMDTag == "2T1N0"); assert(SamTags::updateMDTag(samRecord, reference)); // Write as Sam. assert(outSam.WriteRecord(samHeader, samRecord)); }
void *DL_PREFIX(dlopen)(const char *path, int mode) { const struct stat *sbuf; struct dlstatus *dls; const char *fullPath; dolock(); resetdlerror(); if (!path) { dls = &mainStatus; goto dlopenok; } if (!(sbuf = findFile(path, &fullPath))) { error("file \"%s\" not found", path); goto dlopenerror; } /* Now checks that it hasn't been closed already */ if ((dls = lookupStatus(sbuf)) && (dls->refs > 0)) { /* debug("status found"); */ dls = reference(dls, mode); goto dlopenok; } #ifdef RTLD_NOLOAD if (isFlagSet(mode, RTLD_NOLOAD)) { error("no existing handle and RTLD_NOLOAD specified"); goto dlopenerror; } #endif if (isFlagSet(mode, RTLD_LAZY) && isFlagSet(mode, RTLD_NOW)) { error("how can I load something both RTLD_LAZY and RTLD_NOW?"); goto dlopenerror; } dls = loadModule(fullPath, sbuf, mode); dlopenok: dounlock(); return (void *)dls; dlopenerror: dounlock(); return NULL; }
void DbgdmProxy::sendTC_SCHVERCONF(Signal* signal, Uint32 ssId) { Ss_TC_SCHVERREQ& ss = ssFind<Ss_TC_SCHVERREQ>(ssId); BlockReference dictRef = ss.m_req.senderRef; if (!lastReply(ss)) return; TcSchVerConf* conf = (TcSchVerConf*)signal->getDataPtrSend(); conf->senderRef = reference(); conf->senderData = ss.m_req.senderData; sendSignal(dictRef, GSN_TC_SCHVERCONF, signal, TcSchVerConf::SignalLength, JBB); ssRelease<Ss_TC_SCHVERREQ>(ssId); }
void getPropertiesFromCIMServer( CIMClient& client, const CIMName& propName, Array <String>& propValues) { CIMProperty prop; Array<CIMKeyBinding> kbArray; CIMKeyBinding kb; String _hostName; kb.setName(PROPERTY_NAME); kb.setValue(propName.getString()); kb.setType(CIMKeyBinding::STRING); _hostName.assign(System::getHostName()); kbArray.append(kb); CIMObjectPath reference(_hostName, PEGASUS_NAMESPACENAME_CONFIG, PEGASUS_CLASSNAME_CONFIGSETTING, kbArray); CIMInstance cimInstance = client.getInstance(PEGASUS_NAMESPACENAME_CONFIG, reference); Uint32 pos = cimInstance.findProperty(PROPERTY_NAME); prop = (CIMProperty)cimInstance.getProperty(pos); propValues.append(prop.getValue().toString()); pos = cimInstance.findProperty(DEFAULT_VALUE); prop = (CIMProperty)cimInstance.getProperty(pos); propValues.append(prop.getValue().toString()); pos = cimInstance.findProperty(CURRENT_VALUE); prop = (CIMProperty)cimInstance.getProperty(pos); propValues.append(prop.getValue().toString()); pos = cimInstance.findProperty(PLANNED_VALUE); prop = (CIMProperty)cimInstance.getProperty(pos); propValues.append(prop.getValue().toString()); pos = cimInstance.findProperty(DYNAMIC_PROPERTY); prop = (CIMProperty)cimInstance.getProperty(pos); propValues.append(prop.getValue().toString()); }
void Trpman::execENABLE_COMREQ(Signal* signal) { jamEntry(); const EnableComReq *enableComReq = (const EnableComReq *)signal->getDataPtr(); /* Need to copy out signal data to not clobber it with sendSignal(). */ BlockReference senderRef = enableComReq->m_senderRef; Uint32 senderData = enableComReq->m_senderData; Uint32 nodes[NodeBitmask::Size]; MEMCOPY_NO_WORDS(nodes, enableComReq->m_nodeIds, NodeBitmask::Size); /* Enable communication with all our NDB blocks to these nodes. */ Uint32 search_from = 1; for (;;) { Uint32 tStartingNode = NodeBitmask::find(nodes, search_from); if (tStartingNode == NodeBitmask::NotFound) break; search_from = tStartingNode + 1; if (!handles_this_node(tStartingNode)) continue; globalTransporterRegistry.setIOState(tStartingNode, NoHalt); setNodeInfo(tStartingNode).m_connected = true; //----------------------------------------------------- // Report that the version of the node //----------------------------------------------------- signal->theData[0] = NDB_LE_ConnectedApiVersion; signal->theData[1] = tStartingNode; signal->theData[2] = getNodeInfo(tStartingNode).m_version; signal->theData[3] = getNodeInfo(tStartingNode).m_mysql_version; sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 4, JBB); //----------------------------------------------------- } EnableComConf *enableComConf = (EnableComConf *)signal->getDataPtrSend(); enableComConf->m_senderRef = reference(); enableComConf->m_senderData = senderData; MEMCOPY_NO_WORDS(enableComConf->m_nodeIds, nodes, NodeBitmask::Size); sendSignal(senderRef, GSN_ENABLE_COMCONF, signal, EnableComConf::SignalLength, JBA); }
int main(void) { value(); printf("\n\n"); reference(); printf("\n\n"); char array[] = "oitate"; call_by_array(array); call_by_array_refer(array); struct structure str = {99, "oitate"}; return 0; }
void dense_storage_copy() { static const int Size = ((Rows==Dynamic || Cols==Dynamic) ? Dynamic : Rows*Cols); typedef DenseStorage<T,Size, Rows,Cols, 0> DenseStorageType; const int rows = (Rows==Dynamic) ? 4 : Rows; const int cols = (Cols==Dynamic) ? 3 : Cols; const int size = rows*cols; DenseStorageType reference(size, rows, cols); T* raw_reference = reference.data(); for (int i=0; i<size; ++i) raw_reference[i] = static_cast<T>(i); DenseStorageType copied_reference(reference); const T* raw_copied_reference = copied_reference.data(); for (int i=0; i<size; ++i) VERIFY_IS_EQUAL(raw_reference[i], raw_copied_reference[i]); }
obj* readprog(void) { char *token = NULL; int c; size_t tokensize = 0; c = getchar(); while(c >=0 && isspace(c)) c = getchar(); if(c == '`') { obj *lambda, *argument; lambda = readprog(); argument = readprog(); return apply(lambda, argument); } else if(c == '\\') { return lambda(readprog()); } for(;;) { if(c<0) raiseerror("unexpected EOF"); if(isspace(c)) break; if(c == '`' || c == '\\') { ungetc(c, stdin); break; } token = xrealloc(token, ++tokensize); token[tokensize - 1] = c; c = getchar(); } token = xrealloc(token, ++tokensize); token[tokensize - 1] = 0; if(isnum(token)) { return reference(strtoul(token, NULL, 10)); } else { return symbol(token); } }
void UmlEntryPointPseudoState::write(FileOut & out) { UmlEntryPointPseudoState * ref = reference(); out.indent(); if (ref != 0) out << "<connection"; else out << "<subvertex xmi:type=\"uml:Pseudostate\""; out.id(this); if (! name().isEmpty()) { out << " name=\""; out.quote(name()); out << '"'; } if (ref != 0) { out.ref(ref, "entry"); out << ">\n"; } else out << " kind=\"entryPoint\">\n"; out.indent(+1); write_description_properties(out); while (! _incoming_trans.isEmpty()) _incoming_trans.take(0)->write_in(out); const QVector<UmlItem> ch = children(); unsigned n = ch.size(); unsigned i; for (i = 0; i != n; i += 1) ch[i]->write(out); out.indent(-1); out.indent(); if (ref != 0) out << "</connection>\n"; else out << "</subvertex>\n"; unload(); }
void TestModel::testObjectReferenceToDestroyedObject() { /// create a model std::auto_ptr<Model> model(new Model("TestModel::testObjectReferenceToDestroyedObject")) ; //// fill the model Object* object = model->createObject() ; ObjectReference reference(object) ; model->destroyObject(object) ; CPPUNIT_ASSERT(!reference) ; { Object* object2 = reference ; CPPUNIT_ASSERT(!object2) ; } }
bool Reference::init_ref() { if (reference()) { // this may fail in the scenario of two threads assigning the pointer for the FIRST TIME // at the same time, which is never likely to happen (would be crazy to do) // so don't do it. if (refcount_init.get() > 0) { refcount_init.unref(); unreference(); // first referencing is already 1, so compensate for the ref above } return true; } else { return false; } }
void DefinitionDownloader::saveData(QNetworkReply *reply) { const QString &urlPath = m_url.path(); const QString &fileName = urlPath.right(urlPath.length() - urlPath.lastIndexOf(QLatin1Char('/')) - 1); Utils::FileSaver saver(m_localPath + fileName, QIODevice::Text); const QByteArray data = reply->readAll(); saver.write(data); m_status = saver.finalize() ? Ok: WriteError; QString content = QString::fromUtf8(data); QRegExp reference(QLatin1String("context\\s*=\\s*\"[^\"]*##([^\"]+)\"")); int index = -1; forever { index = reference.indexIn(content, index + 1); if (index == -1) break; emit foundReferencedDefinition(reference.cap(1)); } }
void tst_QOpenGL::fboTextureOwnership() { QFETCH(int, surfaceClass); QScopedPointer<QSurface> surface(createSurface(surfaceClass)); QOpenGLContext ctx; QVERIFY(ctx.create()); ctx.makeCurrent(surface.data()); if (!QOpenGLFramebufferObject::hasOpenGLFramebufferObjects()) QSKIP("QOpenGLFramebufferObject not supported on this platform"); QOpenGLFramebufferObjectFormat fboFormat; fboFormat.setAttachment(QOpenGLFramebufferObject::NoAttachment); QOpenGLFramebufferObject *fbo = new QOpenGLFramebufferObject(200, 100, fboFormat); QVERIFY(fbo->texture() != 0); fbo->bind(); // pull out the texture GLuint texture = fbo->takeTexture(); QVERIFY(texture != 0); QVERIFY(fbo->texture() == 0); // verify that the next bind() creates a new texture fbo->bind(); QVERIFY(fbo->texture() != 0 && fbo->texture() != texture); glClearColor(1.0, 0.0, 0.0, 1.0); glClear(GL_COLOR_BUFFER_BIT); glFinish(); QImage fb = fbo->toImage().convertToFormat(QImage::Format_RGB32); QImage reference(fb.size(), QImage::Format_RGB32); reference.fill(0xffff0000); QFUZZY_COMPARE_IMAGES(fb, reference); glDeleteTextures(1, &texture); delete fbo; }
void Dbtup::execDROP_TRIG_REQ(Signal* signal) { jamEntry(); BlockReference senderRef = signal->getSendersBlockRef(); const DropTrigReq reqCopy = *(const DropTrigReq*)signal->getDataPtr(); const DropTrigReq* const req = &reqCopy; // Find table TablerecPtr tabPtr; tabPtr.i = req->getTableId(); ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec); // Drop trigger Uint32 r = dropTrigger(tabPtr.p, req, refToBlock(senderRef)); if (r == 0){ // Send conf DropTrigConf* const conf = (DropTrigConf*)signal->getDataPtrSend(); conf->setUserRef(senderRef); conf->setConnectionPtr(req->getConnectionPtr()); conf->setRequestType(req->getRequestType()); conf->setTableId(req->getTableId()); conf->setIndexId(req->getIndexId()); conf->setTriggerId(req->getTriggerId()); sendSignal(senderRef, GSN_DROP_TRIG_CONF, signal, DropTrigConf::SignalLength, JBB); } else { // Send ref DropTrigRef* const ref = (DropTrigRef*)signal->getDataPtrSend(); ref->setUserRef(senderRef); ref->setConnectionPtr(req->getConnectionPtr()); ref->setRequestType(req->getRequestType()); ref->setTableId(req->getTableId()); ref->setIndexId(req->getIndexId()); ref->setTriggerId(req->getTriggerId()); ref->setErrorCode((DropTrigRef::ErrorCode)r); ref->setErrorLine(__LINE__); ref->setErrorNode(refToNode(reference())); sendSignal(senderRef, GSN_DROP_TRIG_REF, signal, DropTrigRef::SignalLength, JBB); } }//Dbtup::DROP_TRIG_REQ()
void Dbtux::dropIndex(Signal* signal, IndexPtr indexPtr, Uint32 senderRef, Uint32 senderData) { jam(); /* * Index state should be Defining or Dropping but in 7.0 it can also * be NotDefined (due to double call). The Index record is always * consistent regardless of state so there is no state assert here. */ // drop fragments while (indexPtr.p->m_numFrags > 0) { jam(); Uint32 i = --indexPtr.p->m_numFrags; FragPtr fragPtr; c_fragPool.getPtr(fragPtr, indexPtr.p->m_fragPtrI[i]); /* * Verify that LQH has terminated scans. (If not, then drop order * must change from TUP,TUX to TUX,TUP and we must wait for scans). */ ScanOpPtr scanPtr; bool b = fragPtr.p->m_scanList.first(scanPtr); ndbrequire(!b); c_fragPool.release(fragPtr); } // drop attributes if (indexPtr.p->m_descPage != RNIL) { jam(); freeDescEnt(indexPtr); indexPtr.p->m_descPage = RNIL; } if (senderRef != 0) { jam(); // reply to sender DropTabConf* const conf = (DropTabConf*)signal->getDataPtrSend(); conf->senderRef = reference(); conf->senderData = senderData; conf->tableId = indexPtr.i; sendSignal(senderRef, GSN_DROP_TAB_CONF, signal, DropTabConf::SignalLength, JBB); } new (indexPtr.p) Index(); }
void Restore::open_file(Signal* signal, FilePtr file_ptr) { signal->theData[0] = NDB_LE_StartReadLCP; signal->theData[1] = file_ptr.p->m_table_id; signal->theData[2] = file_ptr.p->m_fragment_id; sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB); FsOpenReq * req = (FsOpenReq *)signal->getDataPtrSend(); req->userReference = reference(); req->fileFlags = FsOpenReq::OM_READONLY | FsOpenReq::OM_GZ; req->userPointer = file_ptr.i; FsOpenReq::setVersion(req->fileNumber, 5); FsOpenReq::setSuffix(req->fileNumber, FsOpenReq::S_DATA); FsOpenReq::v5_setLcpNo(req->fileNumber, file_ptr.p->m_lcp_no); FsOpenReq::v5_setTableId(req->fileNumber, file_ptr.p->m_table_id); FsOpenReq::v5_setFragmentId(req->fileNumber, file_ptr.p->m_fragment_id); sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, FsOpenReq::SignalLength, JBA); }
Node* bubbleSortList(Node * pList) { Node *pResult = reference(pList); Node *p, *q, *end = NULL; q = pResult->next; while (q->next != end) { for (p = q; p->next != end; p = p->next) { if (p->value>p->next->value) { Node bf; bf.value = p->next->value; p->next->value = p->value; p->value = bf.value; } } end = p; } return pResult; }
typename fcppt::container::bitfield::object< ElementType, NumElements, InternalType >::reference fcppt::container::bitfield::object< ElementType, NumElements, InternalType >::operator[]( ElementType const _index ) { return reference( array_, this->to_index( _index ) ); }
int main(int argc, char **argv) { init(argc, argv); /* GENERATE REFERENCE TIME */ reference("reference time", &refer); /* TEST DYNAMIC,n */ cksz = 1; while (cksz <= itersperthr) { sprintf(testName, "DYNAMIC %d", cksz); benchmark(testName, &testdynamicn); cksz *= 2; } finalise(); return EXIT_SUCCESS; }
void DblqhProxy::completeLCP_1(Signal* signal) { ndbrequire(c_lcpRecord.m_state == LcpRecord::L_RUNNING); c_lcpRecord.m_state = LcpRecord::L_COMPLETING_1; ndbrequire(c_lcpRecord.m_complete_outstanding == 0); /** * send LCP_FRAG_ORD (lastFragmentFlag = true) * to all LQH instances... * they will reply with LCP_COMPLETE_REP */ LcpFragOrd* ord = (LcpFragOrd*)signal->getDataPtrSend(); ord->lcpId = c_lcpRecord.m_lcpId; ord->lastFragmentFlag = true; for (Uint32 i = 0; i<c_workers; i++) { jam(); c_lcpRecord.m_complete_outstanding++; sendSignal(workerRef(i), GSN_LCP_FRAG_ORD, signal, LcpFragOrd::SignalLength, JBB); } /** * send END_LCP_REQ to all pgman instances (except "extra" pgman) * they will reply with END_LCP_CONF */ EndLcpReq* req = (EndLcpReq*)signal->getDataPtrSend(); req->senderData= 0; req->senderRef= reference(); req->backupPtr= 0; req->backupId= c_lcpRecord.m_lcpId; for (Uint32 i = 0; i<c_workers; i++) { jam(); c_lcpRecord.m_complete_outstanding++; sendSignal(numberToRef(PGMAN, workerInstance(i), getOwnNodeId()), GSN_END_LCP_REQ, signal, EndLcpReq::SignalLength, JBB); } }
/*! Constructs a DocLnkSet that contains DocLnk objects representing all the files in the \a directory (and any subdirectories, recursively). If \a mimefilter is not null, only documents with a MIME type matching \a mimefilter are selected. The value may contain multiple wild-card patterns separated by ";", such as \c{*o/mpeg;audio/x-wav}. See also \link applnk.html#files-and-links Files and Links\endlink. */ DocLnkSet::DocLnkSet( const QString &directory, const QString& mimefilter ) : AppLnkSet() { QDir dir( directory ); mFile = dir.dirName(); QDict<void> reference(1021); QStringList subFilter = QStringList::split(";", mimefilter); QValueList<QRegExp> mimeFilters; for( QStringList::Iterator it = subFilter.begin(); it != subFilter.end(); ++ it ) mimeFilters.append( QRegExp(*it, FALSE, TRUE) ); findChildren(directory, mimeFilters, reference); const QList<DocLnk> &list = children(); for ( QListIterator<DocLnk> it( list ); it.current(); ++it ) { reference.remove( (*it)->file() ); } for ( QDictIterator<void> dit(reference); dit.current(); ++dit ) { if ( dit.current() == (void*)2 ) { // Unreferenced, make an unwritten link DocLnk* dl = new DocLnk; QFileInfo fi( dit.currentKey() ); dl->setFile(fi.filePath()); dl->setName(fi.baseName()); // #### default to current path? // dl->setCategories( ... ); bool match = mimefilter.isNull(); if ( !match ) for( QValueList<QRegExp>::Iterator it = mimeFilters.begin(); it != mimeFilters.end() && !match; ++ it ) if ( (*it).match(dl->type()) >= 0 ) match = TRUE; if ( match /* && dl->type() != "application/octet-stream" */ && !!dl->exec() ) add(dl); else delete dl; } } }
void Qmgr::initData() { creadyDistCom = ZFALSE; // Records with constant sizes nodeRec = new NodeRec[MAX_NODES]; cnoCommitFailedNodes = 0; c_maxDynamicId = 0; c_clusterNodes.clear(); c_stopReq.senderRef = 0; /** * Check sanity for NodeVersion */ ndbrequire((Uint32)NodeInfo::DB == 0); ndbrequire((Uint32)NodeInfo::API == 1); ndbrequire((Uint32)NodeInfo::MGM == 2); NodeRecPtr nodePtr; nodePtr.i = getOwnNodeId(); ptrAss(nodePtr, nodeRec); nodePtr.p->blockRef = reference(); c_connectedNodes.set(getOwnNodeId()); setNodeInfo(getOwnNodeId()).m_version = NDB_VERSION; /** * Timeouts */ const ndb_mgm_configuration_iterator * p = m_ctx.m_config.getOwnConfigIterator(); ndbrequire(p != 0); Uint32 hbDBAPI = 1500; ndb_mgm_get_int_parameter(p, CFG_DB_API_HEARTBEAT_INTERVAL, &hbDBAPI); setHbApiDelay(hbDBAPI); }//Qmgr::initData()
void DblqhProxy::completeLCP_3(Signal* signal) { jamEntry(); ndbrequire(c_lcpRecord.m_state == LcpRecord::L_COMPLETING_2); c_lcpRecord.m_state = LcpRecord::L_COMPLETING_3; /** * And finally also checkpoint UNDO LOG * and inform TSMAN that checkpoint is "complete" */ EndLcpReq* req = (EndLcpReq*)signal->getDataPtrSend(); req->senderData= 0; req->senderRef= reference(); req->backupPtr= 0; req->backupId= c_lcpRecord.m_lcpId; // no reply from this sendSignal(TSMAN_REF, GSN_END_LCP_REQ, signal, EndLcpReq::SignalLength, JBB); if (c_lcpRecord.m_lcp_frag_rep_cnt) { jam(); c_lcpRecord.m_complete_outstanding++; sendSignal(LGMAN_REF, GSN_END_LCP_REQ, signal, EndLcpReq::SignalLength, JBB); } else { jam(); /** * lgman does currently not like 0 fragments, * cause then it does not get a LCP_FRAG_ORD * * this should change so that it gets this first (style) */ sendLCP_COMPLETE_REP(signal); } }
void TestSwitchingUpdateRuleOutputUpdateRuleInfo() { std::string output_directory = "TestCaSwitchingUpdateRulesOutputParameters"; OutputFileHandler output_file_handler(output_directory, false); // Test with RandomCaSwitchingUpdateRule RandomCaSwitchingUpdateRule<2> random_switching_update_rule; random_switching_update_rule.SetSwitchingParameter(1.0); TS_ASSERT_EQUALS(random_switching_update_rule.GetIdentifier(), "RandomCaSwitchingUpdateRule-2"); out_stream random_switching_update_rule_parameter_file = output_file_handler.OpenOutputFile("random_switching_update_rule_results.parameters"); random_switching_update_rule.OutputUpdateRuleInfo(random_switching_update_rule_parameter_file); random_switching_update_rule_parameter_file->close(); // Compare the generated file in test output with a reference copy in the source code. FileFinder generated = output_file_handler.FindFile("random_switching_update_rule_results.parameters"); FileFinder reference("cell_based/test/data/TestCaUpdateRules/random_switching_update_rule_results.parameters", RelativeTo::ChasteSourceRoot); FileComparison comparer(generated, reference); TS_ASSERT(comparer.CompareFiles()); }
void TestUpdateRuleOutputUpdateRuleInfo() { std::string output_directory = "TestCaUpdateRulesOutputParameters"; OutputFileHandler output_file_handler(output_directory, false); // Test with VolumeConstraintPottsUpdateRule DiffusionCaUpdateRule<2> diffusion_update_rule; diffusion_update_rule.SetDiffusionParameter(1.0); TS_ASSERT_EQUALS(diffusion_update_rule.GetIdentifier(), "DiffusionCaUpdateRule-2"); out_stream diffusion_update_rule_parameter_file = output_file_handler.OpenOutputFile("diffusion_update_rule_results.parameters"); diffusion_update_rule.OutputUpdateRuleInfo(diffusion_update_rule_parameter_file); diffusion_update_rule_parameter_file->close(); // Compare the generated file in test output with a reference copy in the source code. FileFinder generated = output_file_handler.FindFile("diffusion_update_rule_results.parameters"); FileFinder reference("cell_based/test/data/TestCaUpdateRules/diffusion_update_rule_results.parameters", RelativeTo::ChasteSourceRoot); FileComparison comparer(generated, reference); TS_ASSERT(comparer.CompareFiles()); }
status_t GetThreadStateJob::Do() { CpuState* state = NULL; status_t error = fDebuggerInterface->GetCpuState(fThread->ID(), state); BReference<CpuState> reference(state, true); AutoLocker<Team> locker(fThread->GetTeam()); if (fThread->State() != THREAD_STATE_UNKNOWN) return B_OK; if (error == B_OK) { fThread->SetState(THREAD_STATE_STOPPED); fThread->SetCpuState(state); } else if (error == B_BAD_THREAD_STATE) { fThread->SetState(THREAD_STATE_RUNNING); } else return error; return B_OK; }