void HttpCache::clean() { CacheElement *pData; iterator iterEnd = end(); for (iterator iter = begin(); iter != iterEnd;) { pData = iter.second(); if (pData->getRef() == 0) { long t = DateTime::s_curTime - pData->getLastAccess(); if (t > CACHE_TIMEOUT) { iterator iterDel = iter; iter = next(iter); erase(iterDel); recycle(pData); continue; } else if (t > CACHE_DATA_TIMEOUT) pData->release(); } iter = next(iter); } for (DirtyCacheList::iterator it = m_dirty.begin(); it != m_dirty.end();) { if (!(*it)->isInUse()) { recycle(*it); it = m_dirty.erase(it); } else ++it; } }
int LogFlushTask::start() { int rt = 0; m_pTimer = new MUTimer(MURegister::getInstance()->getEpoll(), this); rt = m_pTimer->create(); if (-1 == rt) { ERROR_LOG("create timer error"); recycle(m_pTimer); m_pTimer = NULL; return -1; } rt = m_pTimer->setTime(LOG_FLUSH_PERIOD, LOG_FLUSH_PERIOD); if (-1 == rt) { ERROR_LOG("timer set time error"); recycle(m_pTimer); m_pTimer = NULL; return -1; } return 0; }
void test_object_life_cycle() { Bird* bird = new(Bird); ff(bird, fly, nil); ff(bird, flyhigh, nil); ff(bird, singAsong, "a song from child"); ff(bird, fatherAge, nil); //ff(bird, cannotResponseThis, nil); shift(bird, BirdModeA); ff(bird, modemethodC, nil); shift_back(bird); recycle(bird); //one create on delete Bird* bird2 = new(Bird); debug_log("bird2 pointer %p\n", bird2); Bird* bird3 = new(Bird); debug_log("bird2 pointer %p\n", bird3); Bird* bird31 = new(Bird); debug_log("bird2 pointer %p\n", bird31); info(Bird); info(BirdFather); info(BirdGrandFather); recycle(bird2); recycle(bird3); //release(&bird31); info(Bird); info(BirdFather); info(BirdGrandFather); Bird* b1=new(Bird); Bird* b2=new(Bird); info(Bird); info(BirdFather); info(BirdGrandFather); recycle(b1); recycle(b2); clear(Bird); clear(BirdFather); clear(BirdGrandFather); info(Bird); info(BirdFather); info(BirdGrandFather); }
void HttpCache::releaseAll() { dirtyAll(); for (DirtyCacheList::iterator iter = m_dirty.begin(); iter != m_dirty.end(); ++iter) recycle(*iter); }
/** * A request to recycle this message was received. Forward that request to * the connection message manager for processing. Errors and exceptions * from the manager's recycle member function should be passed back up the * call chain. The caller to message::recycle will deal with them. * * Recycle must *only* be called by the message shared_ptr's destructor. * Once recycled successfully, ownership of the memory has been passed to * another system and must not be accessed again. * * @return true if the message was successfully recycled, false otherwise. */ bool recycle() { typename con_msg_manager::ptr shared = m_manager.lock(); if (shared) { return shared->(recycle(this)); } else { return false;
LogFlushTask::~LogFlushTask() { if (NULL != m_pTimer) { recycle(m_pTimer); m_pTimer = NULL; } }
int VMemBuf::shrinkBuf( long size ) { /* if ( m_type == VMBUF_FILE_MAP ) { if ( s_iMaxAnonMapBlocks - s_iCurAnonMapBlocks > s_iMaxAnonMapBlocks / 10 ) { deallocate(); if ( set( VMBUF_ANON_MAP , getBlockSize() ) == -1 ) return -1; return 0; } } */ if ( size < 0 ) size = 0; if (( m_type == VMBUF_FILE_MAP )&&( m_fd != -1 )) { if ( m_curTotalSize > (unsigned long) size ) ftruncate( m_fd, size ); } BlockBuf * pBuf; while( m_curTotalSize > (size_t)size ) { pBuf = m_bufList.pop_back(); m_curTotalSize -= pBuf->getBlockSize(); recycle( pBuf ); } if ( !m_bufList.empty()) { m_pCurWBlock = m_pCurRBlock = m_bufList.begin(); } return 0; }
/** * rig_protobuf_c_data_buffer_discard: * @buffer: the buffer to discard data from. * @max_discard: maximum number of bytes to discard. * * Removes up to @max_discard data from the beginning of the buffer, * and returns the number of bytes actually discarded. * * returns: number of bytes discarded. */ size_t rig_protobuf_c_data_buffer_discard (ProtobufCDataBuffer *buffer, size_t max_discard) { int rv = 0; CHECK_INTEGRITY (buffer); while (max_discard > 0 && buffer->first_frag) { ProtobufCDataBufferFragment *first = buffer->first_frag; if (first->buf_length <= max_discard) { rv += first->buf_length; max_discard -= first->buf_length; buffer->first_frag = first->next; if (!buffer->first_frag) buffer->last_frag = NULL; recycle (buffer->allocator, first); } else { rv += max_discard; first->buf_length -= max_discard; first->buf_start += max_discard; max_discard = 0; } } buffer->size -= rv; CHECK_INTEGRITY (buffer); return rv; }
void testMonkC() { //new a instance LittleBird* abird = new(LittleBird); LittleBird* bbird = new(LittleBird); release(bbird); //static call methods LittleBird_fly(abird, 0, nil); LittleBird_eat(abird, 0, nil); LittleBird_swim(abird,0, nil); //dynamic call methods ff(abird, fly, nil); ff(abird, swim, nil); ff(abird, eat, nil); ff(abird, yourName, nil); //call abs method ff(abird, hello_abs, nil); ff(abird, land_abs, nil); //dynamic call super class methods int fatherage = (int)ff(abird, getAge, nil); printf("my father age is : %d\n", fatherage); recycle(abird); }
int my_rmdir (const TCHAR *name) { struct my_opendir_s *od; int cnt; TCHAR tname[MAX_DPATH]; /* SHFileOperation() ignores FOF_NORECURSION when deleting directories.. */ od = my_opendir (name); if (!od) { SetLastError (ERROR_FILE_NOT_FOUND); return -1; } cnt = 0; while (my_readdir (od, tname)) { if (!_tcscmp (tname, _T(".")) || !_tcscmp (tname, _T(".."))) continue; cnt++; break; } my_closedir (od); if (cnt > 0) { SetLastError (ERROR_CURRENT_DIRECTORY); return -1; } return recycle (name); }
void LogFlushTask::destroy(MUTimer *pChannel) { m_pTimer = NULL; FATAL_LOG("log flush task, timer error"); recycle(); }
void CgidConn::cleanUp() { setConnector( NULL ); setState( CLOSING ); ::shutdown( getfd(), SHUT_RDWR ); // close(); recycle(); }
//============================================================================= // Main execution //============================================================================= StatusCode TbPacketRecycler::execute() { for (unsigned int i = 0; i < m_nPlanes; ++i) { const std::string hitLocation = m_hitLocation + std::to_string(i); const std::string trgLocation = m_trgLocation + std::to_string(i); const std::string clusLocation = m_clusLocation + std::to_string(i); LHCb::TbHits* hits = getIfExists<LHCb::TbHits>(hitLocation); LHCb::TbTriggers* trgs = getIfExists<LHCb::TbTriggers>(trgLocation); LHCb::TbClusters* clusters = getIfExists<LHCb::TbClusters>(clusLocation); removeClusters(clusters); recycle(hits, m_streams[i]); recycle(trgs, m_streams[i]); } return StatusCode::SUCCESS; }
void VaapiDecSurfacePool::recycle(VideoRenderBuffer * renderBuf) { if (renderBuf < &m_renderBuffers[0] || renderBuf >= &m_renderBuffers[m_renderBuffers.size()]) { ERROR("recycle invalid render buffer"); return; } recycle(renderBuf->surface, SURFACE_RENDERING); }
CustomPostEffectShader::~CustomPostEffectShader() { if (program_ != 0) { recycle(); } if (vaoID_ != 0) { gl_delete.queueVertexArray(vaoID_); vaoID_ = 0; } }
void LsapiConn::cleanUp() { setConnector( NULL ); reset(); if ( getState() == ABORT ) { close(); } recycle(); }
int HttpCache::dirty(CacheElement *data) { assert(data); remove(data->getKey()); if (data->isInUse()) m_dirty.push_back(data); else recycle(data); return 0; }
void rig_protobuf_c_data_buffer_clear(ProtobufCDataBuffer *to_destroy) { ProtobufCDataBufferFragment *at = to_destroy->first_frag; CHECK_INTEGRITY (to_destroy); while (at) { ProtobufCDataBufferFragment *next = at->next; recycle (to_destroy->allocator, at); at = next; } }
int32_t IIOService::perform( sid_t sid, int32_t type, void * task, void (*recycle)(int32_t, void *) ) { int32_t rc = iolayer_perform( m_IOLayer, sid, type, task, recycle ); if ( rc != 0 ) { recycle( type, task ); } return rc; }
void CallbackQueue::removeObj(CallbackLinkedObj *pObj) { if (!pObj) return; logState("removeObj()", pObj); if (pObj->next()) { m_callbackObjList.remove(pObj); recycle(pObj); } }
void EvtcbQue::removeObj(evtcbnode_s *pObj) { if (!pObj) return; logState("removeObj()", pObj); if (pObj->next()) { m_callbackObjList.remove(pObj); recycle(pObj); } }
/*---------------------------------------------------------------------------*/ struct ip64_addrmap_entry * ip64_addrmap_create(const uip_ip6addr_t *ip6addr, uint16_t ip6port, const uip_ip4addr_t *ip4addr, uint16_t ip4port, uint8_t protocol) { struct ip64_addrmap_entry *m; check_age(); m = memb_alloc(&entrymemb); if(m == NULL) { /* We could not allocate an entry, try to recycle one and try to allocate again. */ if(recycle()) { m = memb_alloc(&entrymemb); } } if(m != NULL) { uip_ip4addr_copy(&m->ip4addr, ip4addr); m->ip4port = ip4port; uip_ip6addr_copy(&m->ip6addr, ip6addr); m->ip6port = ip6port; m->protocol = protocol; m->flags = FLAGS_NONE; m->ip6to4 = 1; m->ip4to6 = 0; timer_set(&m->timer, 0); /* Pick a new, unused local port. First make sure that the mapped_port number does not belong to any active connection. If so, we keep increasing the mapped_port until we're free. */ { struct ip64_addrmap_entry *n; n = list_head(entrylist); while(n != NULL) { if(n->mapped_port == mapped_port) { increase_mapped_port(); n = list_head(entrylist); } else { n = list_item_next(m); } } } m->mapped_port = mapped_port; increase_mapped_port(); list_add(entrylist, m); return m; } return NULL; }
/** * rig_protobuf_c_data_buffer_destruct: * @to_destroy: the buffer to empty. * * Remove all fragments from a buffer, leaving it empty. * The buffer is guaranteed to not to be consuming any resources, * but it also is allowed to start using it again. */ void rig_protobuf_c_data_buffer_reset(ProtobufCDataBuffer *to_destroy) { ProtobufCDataBufferFragment *at = to_destroy->first_frag; CHECK_INTEGRITY (to_destroy); while (at) { ProtobufCDataBufferFragment *next = at->next; recycle (to_destroy->allocator, at); at = next; } to_destroy->first_frag = to_destroy->last_frag = NULL; to_destroy->size = 0; }
GLuint getNextTexture(const uvec2& size) { assert(QThread::currentThread() == qApp->thread()); recycle(); ++_activeTextureCount; auto sizeKey = uvec2ToUint64(size); assert(_textures.count(sizeKey)); auto& textureSet = _textures[sizeKey]; if (!textureSet.returnedTextures.empty()) { auto textureAndFence = textureSet.returnedTextures.front(); textureSet.returnedTextures.pop_front(); waitOnFence(static_cast<GLsync>(textureAndFence.second)); return textureAndFence.first; } return createTexture(size); }
void testLemontea() { MCString* mcstr = ff(new(MCString), initWithCString, "a MCString"); ff(mcstr, add, " the second"); ff(mcstr, add, " the third"); ff(mcstr, add, " the forth\n"); // int i; // for (i=0; i<100; i++) { // int old = LOG_LEVEL; // LOG_LEVEL = MC_ERROR_ONLY; // ff(mcstr, add, " a piece of string"); // LOG_LEVEL = old; // } ff(mcstr, print, nil); release(mcstr); MCClock* mcclock = ff(new(MCClock), setTimeToNow, nil); ff(mcclock, printTime, nil); ff(mcclock, printCurrentGMTTime, nil); recycle(mcclock); MCFile* afile = MCFile_newReadWrite("mcfile.txt", 1); char buff[1024] = "this is a file"; int res = call(afile, MCFile, writeToBegin, 8, buff, 64); printf("writeToBegin result: %d errno: %d\n", res, errno); call(afile, MCFile, printAttribute, nil); release(afile); MCCharBuffer* charbuff = CopyToCharBuffer(NewMCCharBuffer(64*sizeof(char)), "this is a stream make it longer to find out why it is cutted\n"); MCString* mcstring = ff(new(MCString), initWithCString, "this is a stream make it longer to find out why it is cutted\n"); MCStream* stream = ff(new(MCStream), newWithPath, readwrite_fullbuffered, "mcstream.txt"); ff(stream, putCString, charbuff); ff(stream, putMCString, mcstring); release(stream); ReleaseMCBuffer(charbuff); release(mcstring); }
int VMemBuf::convertFileBackedToInMemory() { BlockBuf * pBlock; if ( m_type != VMBUF_FILE_MAP ) return -1; if ( m_pCurWPos == (*m_pCurWBlock)->getBuf() ) { if ( *m_pCurWBlock == m_bufList.back() ) { m_bufList.pop_back(); recycle( *m_pCurWBlock ); if ( !m_bufList.empty() ) { m_noRecycle = 1; s_iCurAnonMapBlocks += m_bufList.size(); int i = 0; while( i < m_bufList.size()) { pBlock = m_bufList[i]; if ( !pBlock->getBuf() ) { if ( remapBlock( pBlock, i * s_iBlockSize ) == -1 ) return -1; } ++i; } } unlink( m_sFileName.c_str() ); ::close( m_fd ); m_fd = -1; m_type = VMBUF_ANON_MAP; if ( !(pBlock = getAnonMapBlock( s_iBlockSize ) )) return -1; appendBlock( pBlock ); if ( m_pCurRPos == m_pCurWPos ) m_pCurRPos = (*m_pCurWBlock)->getBuf(); m_pCurWPos = (*m_pCurWBlock)->getBuf(); return 0; } } return -1; }
/* * Find and recycle any disk archive vsn which are marked for recycling. * Always log remove actions as if recycling is occurring. */ void RecycleDiskArchives(void) { int vsn_i; if (cannot_recycle) { return; } if (*TraceFlags & (1 << TR_debug)) { traceDebug = B_TRUE; } if (*TraceFlags & (1 << TR_misc)) { traceMisc = B_TRUE; } for (vsn_i = 0; vsn_i < table_used; vsn_i++) { VSN_TABLE *vsn_entry = &vsn_table[vsn_permute[vsn_i]]; /* * If it's not disk media, skip it. */ if (IS_DISK_MEDIA(vsn_entry->media) == FALSE) { continue; } ignoreRecycling = B_FALSE; /* * Disk media, check if it needs recycling. Recycle * this disk volume if is_recycling, 'c', flag is set. */ if (vsn_entry->needs_recycling == FALSE && vsn_entry->is_recycling == FALSE) { ignoreRecycling = B_TRUE; } recycle(vsn_entry); } }
void CallbackQueue::run(CallbackLinkedObj *pFirstObj, LsiSession *pSessionFilter) { CallbackLinkedObj *pObj; CallbackLinkedObj *pObjNext; if (pFirstObj == NULL) pObj = (CallbackLinkedObj *)m_callbackObjList.begin(); else pObj = pFirstObj; int count = m_callbackObjList.size(); while (count > 0 && pObj && pObj != (CallbackLinkedObj *)m_callbackObjList.end() && (!pSessionFilter || pObj->m_pSession == pSessionFilter)) { pObjNext = (CallbackLinkedObj *)pObj->next(); logState("run()", pObj); --count; m_callbackObjList.remove(pObj); assert(pObj->m_callback); if (pObj->m_callback) pObj->m_callback((lsi_session_t *)pObj->m_pSession, pObj->m_lParam, pObj->m_pParam); else logState("run()][Error: NULL calback", pObj); /** * Comment: the above cb may release the data, so checking here to avoid * recycle again! */ recycle(pObj); pObj = pObjNext; } assert((pFirstObj && pSessionFilter) || (count == 0)); }
/** * session is a filter. If NULL, run all in queue */ void EvtcbQue::run(evtcbhead_t *session) { evtcbnode_s *pObj; evtcbnode_s *pObjNext; if (session == NULL) pObj = (evtcbnode_s *)m_callbackObjList.begin(); else pObj = session->evtcb_head; assert(m_callbackObjList.size() > 0 || (m_callbackObjList.begin() == m_callbackObjList.end())); //WRONG state!!! while (m_callbackObjList.size() > 0 && pObj && pObj != (evtcbnode_s *)m_callbackObjList.end() && (!session || pObj->m_pSession == session)) { pObjNext = (evtcbnode_s *)pObj->next(); logState("run()", pObj); m_callbackObjList.remove(pObj); if (pObj->m_pSession) pObj->m_pSession->evtcb_head = NULL; assert(pObj->m_callback); if (pObj->m_callback) pObj->m_callback(pObj->m_pSession, pObj->m_lParam, pObj->m_pParam); else logState("run()][Error: NULL calback", pObj); recycle(pObj); pObj = pObjNext; } }
/** * rig_protobuf_c_data_buffer_read: * @buffer: the buffer to read data from. * @data: buffer to fill with up to @max_length bytes of data. * @max_length: maximum number of bytes to read. * * Removes up to @max_length data from the beginning of the buffer, * and writes it to @data. The number of bytes actually read * is returned. * * returns: number of bytes transferred. */ size_t rig_protobuf_c_data_buffer_read(ProtobufCDataBuffer *buffer, void *data, size_t max_length) { size_t rv = 0; size_t orig_max_length = max_length; CHECK_INTEGRITY (buffer); while (max_length > 0 && buffer->first_frag) { ProtobufCDataBufferFragment *first = buffer->first_frag; if (first->buf_length <= max_length) { memcpy (data, rig_protobuf_c_data_buffer_fragment_start (first), first->buf_length); rv += first->buf_length; data = (char *) data + first->buf_length; max_length -= first->buf_length; buffer->first_frag = first->next; if (!buffer->first_frag) buffer->last_frag = NULL; recycle (buffer->allocator, first); } else { memcpy (data, rig_protobuf_c_data_buffer_fragment_start (first), max_length); rv += max_length; first->buf_length -= max_length; first->buf_start += max_length; data = (char *) data + max_length; max_length = 0; } } buffer->size -= rv; assert (rv == orig_max_length || buffer->size == 0); CHECK_INTEGRITY (buffer); return rv; }