Object File::await(uint16_t events, double timeout) { if (isClosed()) { Cell closedResult; closedResult.m_type = KindOfInt64; closedResult.m_data.num = FileAwait::CLOSED; return c_StaticWaitHandle::CreateSucceeded(closedResult); } if (fd() < 0) { throw Object(SystemLib::AllocExceptionObject( "Unable to await on stream, invalid file descriptor")); } events = events & FileEventHandler::READ_WRITE; if (!events) { throw Object(SystemLib::AllocExceptionObject( "Must await for reading, writing, or both.")); } auto ev = new FileAwait(fd(), events, timeout); try { return ev->getWaitHandle(); } catch (...) { assert(false); ev->abandon(); throw; } }
/* Executes a Load Programme instruction. Returns 1 if the UM should quit. */ static int exec_load( void) { int quit = 0; rb = GET_REG_B(insn); reg_b = regs[rb]; if( reg_b >= num_arrays) { fprintf( stderr, "ERROR: OP12 - Array index out of bounds!\n"); quit = 1; } else if( arrays[reg_b] == NULL) { fprintf( stderr, "ERROR: OP12 - Accessing abandoned array!\n"); quit = 1; } else { if( reg_b != 0) { abandon( arrays[0]); arrays[0] = allocate( arrays[reg_b]->platters, 0); memcpy( arrays[0]->array, arrays[reg_b]->array, arrays[0]->platters * sizeof( platter_t)); } rc = GET_REG_C(insn); insn_ptr = arrays[0]->array + regs[rc]; } return quit; }
static Void heapInit() { /* initialise heap storage */ space1 = (Heap)(farCalloc(heapSize,sizeof(Cell))); space2 = (Heap)(farCalloc(heapSize,sizeof(Cell))); if (space1==(Heap)0 || space2==(Heap)0) abandon("Cannot allocate heap storage"); from = space1 + heapSize; to = space2 + heapSize; hp = -heapSize-1; }
static void getAngle(const struct pam * const pamP, sample ** const pixels, unsigned int const hstep, unsigned int const vstep, unsigned int const hsamples, float const maxangle, float const astep, float const qmin, bool const fast, bool const verbose, float * const angleP) { float a; float da; float lastq; /* quality (s/n ratio) of last measurement */ getBestAngleLocal(pamP, pixels, hstep, vstep, hsamples, -maxangle, maxangle, astep, verbose, &a, &lastq); if ((a < -maxangle + astep / 2) || (a > maxangle - astep / 2)) /* extreme val almost certainly wrong */ abandon(); if (lastq < qmin) /* insufficient s/n ratio */ abandon(); /* make a finer search in the neighborhood */ da = astep / 10; getBestAngleLocal(pamP, pixels, hstep, vstep, hsamples, a - 9 * da, a + 9 * da, da, verbose, &a, &lastq); /* iterate once more unless we don't need that much accuracy */ if (!fast) { da /= 10; getBestAngleLocal(pamP, pixels, hstep, vstep, hsamples, a - 9 * da, a + 9 * da, da, verbose, &a, &lastq); } *angleP = a; }
Object MCRouter::issue(mcr::mcrouter_msg_t& msg) { auto ev = new MCRouterResult(this, msg); try { return Object{ev->getWaitHandle()}; } catch (...) { assert(false); ev->abandon(); throw; } }
/** * Abandon all received finished events. * * Returns true iff provided wait handle was abandoned. */ bool AsioExternalThreadEventQueue::abandonAllReceived(c_ExternalThreadEventWaitHandle* wait_handle) { assert(m_received); bool seen = false; do { auto ete_wh = m_received; m_received = m_received->getNextToProcess(); ete_wh->abandon(true); seen |= ete_wh == wait_handle; } while (m_received); return seen; }
static int putConnSocket(int orig_sock,int sock,SAP addr,int leng,PCStr(what),int rcode){ int si; int csi = -1; SockPool *sp; SockPool *osp = 0; double Now = Time(); double oTime; int csock = -1; oTime = Now; setupCSC("putConnSocket",sockCSC,sizeof(sockCSC)); enterCSC(sockCSC); for( si = 0; si < elnumof(sockPool); si++ ){ sp = &sockPool[si]; if( sp->sp_Time != 0 ){ if( sp->sp_Time < oTime ) osp = sp; continue; } osp = sp; csi = si; break; } if( osp ){ if( osp->sp_Time ){ LOGX_tcpConAbandon1++; abandon(osp,0); } sockPoolN++; setfdowner(sock,0,0); osp->sp_what = what; osp->sp_Time = Time(); osp->sp_sock = sock; osp->sp_rcode = rcode; osp->sp_leng = leng; bcopy(addr,&osp->sp_addr,leng); if( rcode != RCODE_RECYC ){ porting_dbg("--putConnSocket(%d) %d[%d]", sockPoolN,sock,csi,csock); porting_dbg("++putConnSock(%s)[%d] (%d)%d[%d]", what,sock,csi,osp->sp_leng,osp->sp_sock); } syslog_ERROR("--putConnSocket([%d]%d)<-[%d]%d %s %d\n", sock,SocketOf(sock),orig_sock,SocketOf(orig_sock), what,rcode); } leaveCSC(sockCSC); return 0; }
/* Executes an Abandonment instruction. Returns 1 if the UM should quit. */ static int exec_aban( void) { int quit = 0; rc = GET_REG_C(insn); reg_c = regs[rc]; if( reg_c == 0) { fprintf( stderr, "ERROR: Cannot abandon 0-th array!\n"); quit = 1; } else { abandon( (void *)reg_c); } return quit; }
void c_ExternalThreadEventWaitHandle::sweep() { assert(getState() == STATE_WAITING); if (m_event->cancel()) { // canceled; the processing thread will take care of cleanup return; } // event has finished, but process() was not called yet auto session = AsioSession::Get(); bool done = false; do { auto ete_wh = session->waitForExternalThreadEvents(); while (ete_wh) { done |= ete_wh == this; auto next_wh = ete_wh->getNextToProcess(); ete_wh->abandon(true); ete_wh = next_wh; } } while (!done); }
/* Executes an Abandonment instruction. Returns 1 if the UM should quit. */ static int exec_aban( void) { int quit = 0; rc = GET_REG_C(insn); reg_c = regs[rc]; if( reg_c == 0) { fprintf( stderr, "ERROR: OP09 - Cannot abandon 0-th array!\n"); quit = 1; } else if( reg_c >= num_arrays) { fprintf( stderr, "ERROR: OP09 - Array index out of bounds!\n"); quit = 1; } else if( arrays[reg_c] == NULL) { fprintf( stderr, "ERROR: OP09 - Array already abandoned!\n"); quit = 1; } else { freed_array_t *f; abandon( arrays[reg_c]); arrays[reg_c] = NULL; /* Remember the slot that was holding this array. */ f = emalloc( sizeof( freed_array_t)); f->idx = reg_c; f->next = freed_arrays; freed_arrays = f; } return quit; }
static void computeSteps(const struct pam * const pamP, unsigned int const hstepReq, unsigned int const vstepReq, unsigned int * const hstepP, unsigned int * const vstepP) { /*---------------------------------------------------------------------------- Adjust parameters if necessary now that we have the image size -----------------------------------------------------------------------------*/ if (pamP->width < 10 || pamP->height < 10) abandon(); if (pamP->width < 10 * hstepReq) *hstepP = pamP->width / 10; else *hstepP = hstepReq; if (pamP->height < 10 * vstepReq) *vstepP = pamP->height / 10; else *vstepP = vstepReq; }
/* Executes a Load Programme instruction. Returns 1 if the UM should quit. */ static int exec_load( void) { int quit = 0; rb = GET_REG_B(insn); reg_b = regs[rb]; if( reg_b != 0) { unsigned int platters = *(unsigned int *)(reg_b - sizeof( platter_t)); abandon( array_0); array_0 = allocate( platters, 0); memcpy( array_0, (void *)reg_b, platters * sizeof( platter_t)); } rc = GET_REG_C(insn); reg_c = regs[rc]; insn_ptr = array_0 + reg_c; return quit; }
void action(struct map *map) { int tmp; printf("What do you want to do ?\n" "\t1) Abandon\n" "\t2) Set a flag\n" "\t3) Erase a flag\n" "\t4) Explore a cell\n" "\t5) Quit\n\t"); scanf("%d", &tmp); if(tmp == 1) abandon(); else if(tmp == 2) flag(map); else if(tmp == 3) unflag(map); else if(tmp == 4) explore(map); else if(tmp == 5) quit(map); #if defined CHEAT_ALLOWED else if(tmp == 16012006) display_map_debug(map); #endif }
SurfaceTexture::~SurfaceTexture() { ST_LOGV("~SurfaceTexture"); abandon(); }
void ConsumerBase::onLastStrongRef(const void* id) { abandon(); }
boost::optional<Date_t> CollectionRangeDeleter::cleanUpNextRange( OperationContext* opCtx, NamespaceString const& nss, OID const& epoch, int maxToDelete, CollectionRangeDeleter* forTestOnly) { if (maxToDelete <= 0) { maxToDelete = rangeDeleterBatchSize.load(); if (maxToDelete <= 0) { maxToDelete = std::max(int(internalQueryExecYieldIterations.load()), 1); } } StatusWith<int> wrote = 0; auto range = boost::optional<ChunkRange>(boost::none); auto notification = DeleteNotification(); { UninterruptibleLockGuard noInterrupt(opCtx->lockState()); AutoGetCollection autoColl(opCtx, nss, MODE_IX); auto* const collection = autoColl.getCollection(); auto* const csr = CollectionShardingRuntime::get(opCtx, nss); auto& metadataManager = csr->_metadataManager; if (!_checkCollectionMetadataStillValid( opCtx, nss, epoch, forTestOnly, collection, metadataManager)) { return boost::none; } auto* const self = forTestOnly ? forTestOnly : &metadataManager->_rangesToClean; bool writeOpLog = false; { stdx::lock_guard<stdx::mutex> scopedLock(csr->_metadataManager->_managerLock); if (self->isEmpty()) { LOG(1) << "No further range deletions scheduled on " << nss.ns(); return boost::none; } auto& orphans = self->_orphans; if (orphans.empty()) { // We have delayed deletions; see if any are ready. auto& df = self->_delayedOrphans.front(); if (df.whenToDelete > Date_t::now()) { LOG(0) << "Deferring deletion of " << nss.ns() << " range " << redact(df.range.toString()) << " until " << df.whenToDelete; return df.whenToDelete; } // Move a single range from _delayedOrphans to _orphans orphans.splice(orphans.end(), self->_delayedOrphans, self->_delayedOrphans.begin()); LOG(1) << "Proceeding with deferred deletion of " << nss.ns() << " range " << redact(orphans.front().range.toString()); writeOpLog = true; } invariant(!orphans.empty()); const auto& frontRange = orphans.front().range; range.emplace(frontRange.getMin().getOwned(), frontRange.getMax().getOwned()); notification = orphans.front().notification; } invariant(range); if (writeOpLog) { // Secondaries will watch for this update, and kill any queries that may depend on // documents in the range -- excepting any queries with a read-concern option // 'ignoreChunkMigration' try { AutoGetCollection autoAdmin( opCtx, NamespaceString::kServerConfigurationNamespace, MODE_IX); Helpers::upsert(opCtx, NamespaceString::kServerConfigurationNamespace.ns(), BSON("_id" << "startRangeDeletion" << "ns" << nss.ns() << "epoch" << epoch << "min" << range->getMin() << "max" << range->getMax())); } catch (const DBException& e) { stdx::lock_guard<stdx::mutex> scopedLock(csr->_metadataManager->_managerLock); csr->_metadataManager->_clearAllCleanups( scopedLock, e.toStatus("cannot push startRangeDeletion record to Op Log," " abandoning scheduled range deletions")); return boost::none; } } const auto scopedCollectionMetadata = metadataManager->getActiveMetadata(metadataManager, boost::none); const auto& metadata = *scopedCollectionMetadata; try { wrote = self->_doDeletion( opCtx, collection, metadata->getKeyPattern(), *range, maxToDelete); } catch (const DBException& e) { wrote = e.toStatus(); warning() << e.what(); } } // drop autoColl if (!wrote.isOK() || wrote.getValue() == 0) { if (wrote.isOK()) { LOG(0) << "No documents remain to delete in " << nss << " range " << redact(range->toString()); } // Wait for majority replication even when wrote isn't OK or == 0, because it might have // been OK and/or > 0 previously, and the deletions must be persistent before notifying // clients in _pop(). LOG(0) << "Waiting for majority replication of local deletions in " << nss.ns() << " range " << redact(range->toString()); repl::ReplClientInfo::forClient(opCtx->getClient()).setLastOpToSystemLastOpTime(opCtx); const auto clientOpTime = repl::ReplClientInfo::forClient(opCtx->getClient()).getLastOp(); // Wait for replication outside the lock const auto replicationStatus = [&] { try { WriteConcernResult unusedWCResult; return waitForWriteConcern( opCtx, clientOpTime, kMajorityWriteConcern, &unusedWCResult); } catch (const DBException& e) { return e.toStatus(); } }(); // Get the lock again to finish off this range (including notifying, if necessary). // Don't allow lock interrupts while cleaning up. UninterruptibleLockGuard noInterrupt(opCtx->lockState()); AutoGetCollection autoColl(opCtx, nss, MODE_IX); auto* const collection = autoColl.getCollection(); auto* const csr = CollectionShardingRuntime::get(opCtx, nss); auto& metadataManager = csr->_metadataManager; if (!_checkCollectionMetadataStillValid( opCtx, nss, epoch, forTestOnly, collection, metadataManager)) { return boost::none; } auto* const self = forTestOnly ? forTestOnly : &metadataManager->_rangesToClean; stdx::lock_guard<stdx::mutex> scopedLock(csr->_metadataManager->_managerLock); if (!replicationStatus.isOK()) { LOG(0) << "Error when waiting for write concern after removing " << nss << " range " << redact(range->toString()) << " : " << redact(replicationStatus.reason()); // If range were already popped (e.g. by dropping nss during the waitForWriteConcern // above) its notification would have been triggered, so this check suffices to ensure // that it is safe to pop the range here if (!notification.ready()) { invariant(!self->isEmpty() && self->_orphans.front().notification == notification); LOG(0) << "Abandoning deletion of latest range in " << nss.ns() << " after local " << "deletions because of replication failure"; self->_pop(replicationStatus); } } else { LOG(0) << "Finished deleting documents in " << nss.ns() << " range " << redact(range->toString()); self->_pop(wrote.getStatus()); } if (!self->_orphans.empty()) { LOG(1) << "Deleting " << nss.ns() << " range " << redact(self->_orphans.front().range.toString()) << " next."; } return Date_t::now() + Milliseconds(rangeDeleterBatchDelayMS.load()); } invariant(range); invariant(wrote.getStatus()); invariant(wrote.getValue() > 0); notification.abandon(); return Date_t::now() + Milliseconds(rangeDeleterBatchDelayMS.load()); }
ConsumerBase::~ConsumerBase() { CB_LOGV("~ConsumerBase"); abandon(); }
static int getConnSocket(int sock,SAP addr,int leng,int *rcsock,int *pending){ int si; int csi = -1; SockPool *sp; int got_csock = -1; double Now = Time(); double Age = 0; static int getOk; static int getNg; int rcode = -1; setupCSC("getConnSocket",sockCSC,sizeof(sockCSC)); enterCSC(sockCSC); *pending = 0; for( si = 0; si < elnumof(sockPool); si++ ){ sp = &sockPool[si]; if( sp->sp_Time == 0 ) continue; if( PCON_TIMEOUT < Now - sp->sp_Time ){ LOGX_tcpConAbandon2++; abandon(sp,1); continue; } if( sp->sp_leng != leng ){ continue; } if( bcmp(addr,&sp->sp_addr,leng) != 0 && VSA_addrcomp((VSAddr*)addr,&sp->sp_addr) != 0 ){ continue; } rcode = sp->sp_rcode; if( rcode == RCODE_RECYC ){ if( /* HTTP && */ inoutReady(sp->sp_sock,1) || !sock_isconnected(sp->sp_sock) ){ getNg++; /* porting_dbg("--getConnSock(%d/%d) age=%.2f [%d] NO-R %d:%d", si,sockPoolN,Now-sp->sp_Time,sp->sp_sock,getNg,getOk); */ LOGX_tcpConAbandon3++; abandon(sp,2); continue; } LOGX_tcpConRecycleOk++; }else{ if( inoutReady(sp->sp_sock,2) == 0 ){ if( PCON_TIMEOUT < Now - sp->sp_Time ){ porting_dbg("--getConnSock(%d/%d)%s age=%.2f [%d] NO-A", si,sockPoolN,sp->sp_what,Now-sp->sp_Time,sp->sp_sock); LOGX_tcpConAbandon4++; abandon(sp,3); }else{ *pending += 1; } continue; } if( !sock_isconnected(sp->sp_sock) ){ porting_dbg("--getConnSock(%d/%d)%s age=%.2f [%d] NO-B", si,sockPoolN,sp->sp_what,Now-sp->sp_Time,sp->sp_sock); LOGX_tcpConAbandon4++; abandon(sp,3); continue; } } getOk++; if( rcode != RCODE_RECYC ) porting_dbg("--getConnSock(%d/%d)%s age=%.2f [%d] OK (%d)", si,sockPoolN,sp->sp_what,Now-sp->sp_Time,sp->sp_sock,getOk); syslog_ERROR("--getConnSock(%d/%d)%s age=%.2f [%d] OK (%d)\n", si,sockPoolN,sp->sp_what,Now-sp->sp_Time,sp->sp_sock,getOk); Age = Now - sp->sp_Time; sp->sp_Time = 0; sockPoolN--; csi = si; got_csock = sp->sp_sock; break; } leaveCSC(sockCSC); if( got_csock < 0 ){ return -1; } if( rcode != RCODE_RECYC ) porting_dbg("--getConnSocket(%d)[%d]>>>%d[%d]", sockPoolN,sock,csi,got_csock); setfdowner(got_csock,getthreadid(),getthreadgid(0)); *rcsock = got_csock; syslog_ERROR("--getConnSocket([%d]%d)<-[%d]%d %.2f (%d)\n", sock,SocketOf(sock),got_csock,SocketOf(got_csock), Age,*pending); return 0; }