void linearFree(void* mem) { auto node = getNode(mem); if (!node) return; // Free the chunk sLinearPool.Deallocate(node->chunk); // Free the node delNode(node); }
static bool linearInit() { auto blk = MemBlock::Create((u8*)__linear_heap, __linear_heap_size); if (blk) { sLinearPool.AddBlock(blk); rbtree_init(&sAddrMap, addrMapNodeComparator); return true; } return false; }
void Controller::Run() { while(true) { int num = _poller->Wait(-1); while (num--) { int listen_fd; uint64_t u64; uint32_t events; _poller->GetEvent(&u64, &events); if (events != EPOLLIN) { continue; } listen_fd = static_cast<int>(u64); // TODO 目前暂时只支持TCP struct sockaddr_in socket_addr; socklen_t socket_addr_len = sizeof(sockaddr_in); int client = accept(listen_fd, (struct sockaddr *)&socket_addr, &socket_addr_len); // TODO 如果是大量短链接的话,比较....... TaskData * task = static_cast<TaskData*>(gMemPool.Malloc(sizeof(TaskData))); if (!task) { LogErr("alloc task data failed, close client connection, client address: %u:%u\n", socket_addr.sin_addr.s_addr, socket_addr.sin_port); safe_close(client); continue; } uint32_t io_handler_id; uint32_t client_id; SelectIoHandler(client, &io_handler_id, &client_id); task->cmd = kControlAddClient; task->data_type = kTcpData; task->extern_ip = socket_addr.sin_addr.s_addr; task->extern_port = socket_addr.sin_port; task->local_port = _listen_sockets[listen_fd].port; task->fd_id = client_id; task->headler_id = io_handler_id; LOGDEBUG("accept client connection: %u:%u", task->extern_ip, task->extern_port); if (!_task_pool->Put(io_handler_id, static_cast<void*>(task))) { LogInfo("add task to pool failed"); safe_close(client); continue; } } } }
void* linearMemAlign(size_t size, size_t alignment) { // Enforce minimum alignment if (alignment < 16) alignment = 16; // Convert alignment to shift amount int shift; for (shift = 4; shift < 32; shift ++) { if ((1U<<shift) == alignment) break; } if (shift == 32) // Invalid alignment return nullptr; // Initialize the pool if it is not ready if (!sLinearPool.Ready() && !linearInit()) return nullptr; // Allocate the chunk MemChunk chunk; if (!sLinearPool.Allocate(chunk, size, shift)) return nullptr; auto node = newNode(chunk); if (!node) { sLinearPool.Deallocate(chunk); return nullptr; } if (rbtree_insert(&sAddrMap, &node->node)); if (sLinearPool_maxaddr < (u32)sLinearPool.last->base) sLinearPool_maxaddr = (u32)sLinearPool.last->base; return chunk.addr; }
int main() { // TestCase Group1: MemPool objMemPool; MemPool *pMemPool = &objMemPool; int32_t nCount = 10; char *pszArray = NEW_VEC(pMemPool, char, nCount); int32_t *pnArray = NEW_VEC(pMemPool, int32_t, nCount); float *pfArray = NEW_VEC(pMemPool, float, nCount); for (int i = 0; i < nCount; i++) { pszArray[i] = 'a' + i; pnArray[i] = i; pfArray[i] = 1.0 * i; } for (int i = 0; i < nCount; i++) { fprintf(stdout, "pszArray[%d]:\t%c\n", i, pszArray[i]); fprintf(stdout, "pnArray[%d]:\t%d\n", i, pnArray[i]); fprintf(stdout, "pfArray[%d]:\t%f\n", i, pfArray[i]); } pMemPool->reset(); // TestCase Group2: MemPool objMemPool2; MemPool *pMemPool2 = &objMemPool2; int32_t nCount2 = 10; MyClass *pMyClass = NEW(pMemPool2, MyClass); fprintf(stdout, "pMyClass:\t%d\n", pMyClass->getCount()); MyClass *pMyClass2 = NEW(pMemPool2, MyClass)(100); fprintf(stdout, "pMyClass2:\t%d\n", pMyClass2->getCount()); MyClass *pMyClassArray = NEW_ARRAY(pMemPool2, MyClass, nCount2); for (int i = 0; i < nCount2; i++) { fprintf(stdout, "pMyClassArray[%d]:\t%d\n", i, pMyClassArray[i].getCount()); } pMemPool2->reset(); // TestCase Group3: MemPool objMemPool3; MemPool *pMemPool3 = &objMemPool3; MemMonitor memMonitor(pMemPool3, 1); pMemPool3->setMonitor(&memMonitor); memMonitor.enableException(); int32_t nCount3 = 1; char *pszArray3 = NEW_VEC(pMemPool3, char, nCount3); if (!pszArray3) { printf("pszArray3 NEW_VEC Err!\n"); } nCount3 = 1024; int32_t *pnArray3 = NEW_VEC(pMemPool3, int32_t, nCount3); if (!pnArray3) { printf("pnArray3 NEW_VEC Err!\n"); } float *pfArray3 = NEW_VEC(pMemPool3, float, nCount3); if (!pfArray3) { printf("pfArray3 NEW_VEC Err!\n"); } for (int i = 0; i < nCount3; i++) { pszArray3[i] = 'a' + i; pnArray3[i] = i; pfArray3[i] = 1.0 * i; } for (int i = 0; i < nCount3; i++) { fprintf(stdout, "pszArray3[%d]:\t%c\n", i, pszArray3[i]); fprintf(stdout, "pnArray3[%d]:\t%d\n", i, pnArray3[i]); fprintf(stdout, "pfArray3[%d]:\t%f\n", i, pfArray3[i]); } pMemPool3->reset(); // TestCase Group4: MemPool objMemPool4; MemPool *pMemPool4 = &objMemPool4; MemMonitor memMonitor4(pMemPool4, 1); pMemPool4->setMonitor(&memMonitor4); memMonitor4.enableException(); int32_t nCountsz4 = 1024; char *pszArraysz4 = NEW_VEC(pMemPool4, char, nCountsz4); if (!pszArraysz4) { printf("pszArraysz4 is NULL\n"); } MyClass *pMyClass4 = NEW(pMemPool4, MyClass); if (!pMyClass4) { printf("pMyClass4 is NULL\n"); } fprintf(stdout, "pMyClass4:\t%d\n", pMyClass4->getCount()); int32_t nCountsz4_1 = 1024; char *pszArraysz4_1 = NEW_VEC(pMemPool4, char, nCountsz4_1); if (!pszArraysz4_1) { printf("pszArraysz4_1 is NULL\n"); } MyClass *pMyClass4_1 = NEW(pMemPool4, MyClass)(100); if (!pMyClass4_1) { printf("pMyClass4_1 is NULL\n"); } fprintf(stdout, "pMyClass4_1:\t%d\n", pMyClass4_1->getCount()); int32_t nCountsz4_2 = 1024; char *pszArraysz4_2 = NEW_VEC(pMemPool4, char, nCountsz4_2); if (!pszArraysz4_2) { printf("pszArraysz4_2 is NULL\n"); } int32_t nCount4_2 = 1; MyClass *pMyClassArray4_2 = NEW_ARRAY(pMemPool4, MyClass, nCount4_2); if (!pMyClassArray4_2) { printf("pMyClassArray4_2 is NULL\n"); } for (int i = 0; i < nCount4_2; i++) { fprintf(stdout, "pMyClassArray4_2[%d]:\t%d\n", i, pMyClassArray4_2[i].getCount()); } pMemPool4->reset(); return 0; }
void deleteGesture( AbstractGestureEvent *g ){ pool.free( (DragGesture*)g ); }
void clear() { states.clear(); pool.clear(); reset(); }
u32 linearSpaceFree() { return sLinearPool.GetFreeSpace(); }
namespace ef { CMap gConfigureMap; MemPool gMemPool; Controller::ListenFdInfo::~ListenFdInfo() { if (fd >= 0) { safe_close(fd); } } Controller::Controller() { } Controller::~Controller() { // TODO if (_listen_sockets) { delete [] _listen_sockets; _listen_sockets = nullptr; } } bool Controller::Initialize(const char* server_name, const char* configure_file) { _server_name = server_name; _configure_file = configure_file; // 加载配置 if (!gConfigureMap.Load(configure_file)) { printf("error: %s\n", gConfigureMap.GetErrMsg().c_str()); return false; } gConfigureMap.Print(); // 初始化日志 std::string log_path = JoinPath(gConfigureMap["log"]["log_path"].str(), server_name); if (!Logger::Initialize(log_path.c_str(), gConfigureMap["log"]["max_file_size"].as<uint32_t>(DefaultConf::kMaxLogFileSize), gConfigureMap["log"]["max_file_num"].as<uint32_t>(DefaultConf::kMaxLogFileNum), gConfigureMap["log"]["log_level"].c_str())) { printf("logger initialize failed, errmsg: %s\n", Logger::GetErrMsg().c_str()); } LogInfo("Logger initialize succeed\n"); int poller_max_event = gConfigureMap["poller_max_event"].as<int>(DefaultConf::kPollerMaxEventNum); assert(poller_max_event > 0); _poller = new Poller(poller_max_event); assert(_poller); LogInfo("Poller initialize succeed\n"); // 初始化监听端口 // TODO different port bind different protocol(unpack function) // 每个监听端口最好能独立的包完整性检查,每个访问外部server的端口,最好也能绑定独立协议 const Value & val = gConfigureMap["listen"]; _listen_size = val.size() + 128; _listen_sockets = new ListenFdInfo[_listen_size]; for (uint32_t i=0; i<_listen_size; ++i) { unsigned int port = val[i]["port"].as<unsigned>(0); int fd = ListenTcpV4(port); if (fd < 0) { FillErrmsg("listen failed: ", errno); return false; } _listen_sockets[fd].port = port; _listen_sockets[fd].fd = fd; if (_poller->Add(fd, (uint64_t)fd, EPOLLIN)) { FillErrmsg("listen fd add to poller failed: ", errno); return false; } } _io_handler_num = gConfigureMap["server"]["io_handler_num"].as<uint32_t>(DefaultConf::kIoHandlerNum); _io_handers = new IoHandler[_io_handler_num]; assert(_io_handers); for (uint32_t i=0; i<_io_handler_num; ++i) { if(!_io_handers[i].Initialize()) { _errmsg = "io handler initialize failed"; return false; } } _worker_num = gConfigureMap["server"]["worker_num"].as<uint32_t>(DefaultConf::kWorkerNum); _workers = new Worker[_worker_num]; assert(_workers); for (uint32_t i=0; i<_worker_num; ++i) { if(!_workers[i].Initialize()) { _errmsg = "initialize workers failed"; return false; } } int pool_size = _io_handler_num + _worker_num; int queue_size = gConfigureMap["server"]["queue_size"].as<uint32_t>(DefaultConf::kQueueSize); _task_pool = new TaskPool(); assert(_task_pool); if (!_task_pool->Initialize(pool_size, queue_size)) { LogErr("task poll initialize failed"); return false; } return true; } int Controller::ListenTcpV4(unsigned short port) { int sock = socket(AF_INET, SOCK_STREAM, 0); if (sock < 0) { FillErrmsg("create listen socket failed, errmsg: ", errno); return -1; } if (set_nonblock(sock) < 0) { FillErrmsg("set listen socket nonblocked failed, errmsg: ", errno); safe_close(sock); return -1; } struct sockaddr_in addr; addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr.s_addr = INADDR_ANY; if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) == -1) { FillErrmsg("bind failed, errmsg: ", errno); safe_close(sock); return -1; } // TODO socketopt int listen_backlog = gConfigureMap["socket_configure"]["listen_back_log"].as<int>(DefaultConf::kListenBackLog); if (listen(sock, listen_backlog)) { safe_close(sock); return -1; } return sock; } void Controller::Run() { while(true) { int num = _poller->Wait(-1); while (num--) { int listen_fd; uint64_t u64; uint32_t events; _poller->GetEvent(&u64, &events); if (events != EPOLLIN) { continue; } listen_fd = static_cast<int>(u64); // TODO 目前暂时只支持TCP struct sockaddr_in socket_addr; socklen_t socket_addr_len = sizeof(sockaddr_in); int client = accept(listen_fd, (struct sockaddr *)&socket_addr, &socket_addr_len); // TODO 如果是大量短链接的话,比较....... TaskData * task = static_cast<TaskData*>(gMemPool.Malloc(sizeof(TaskData))); if (!task) { LogErr("alloc task data failed, close client connection, client address: %u:%u\n", socket_addr.sin_addr.s_addr, socket_addr.sin_port); safe_close(client); continue; } uint32_t io_handler_id; uint32_t client_id; SelectIoHandler(client, &io_handler_id, &client_id); task->cmd = kControlAddClient; task->data_type = kTcpData; task->extern_ip = socket_addr.sin_addr.s_addr; task->extern_port = socket_addr.sin_port; task->local_port = _listen_sockets[listen_fd].port; task->fd_id = client_id; task->headler_id = io_handler_id; LOGDEBUG("accept client connection: %u:%u", task->extern_ip, task->extern_port); if (!_task_pool->Put(io_handler_id, static_cast<void*>(task))) { LogInfo("add task to pool failed"); safe_close(client); continue; } } } } bool Controller::LoadNetCompleteFunc() { return true; } void Controller::FillErrmsg(const char * extra, int errorno) { char buf[256]; safe_strerror(errorno, buf, 256); _errmsg = extra; _errmsg.append(buf); } const std::string& Controller::GetErrMsg() const { return _errmsg; } void Controller::SelectIoHandler(int fd, uint32_t *io_handler_id, uint32_t *fd_id) { *io_handler_id = (uint32_t)fd % _io_handler_num; *fd_id = (uint32_t)fd / _io_handler_num; } } /* namespace ef */
PPMonoidElemRawPtr PPMonoidOvImpl::myNew(PPMonoidElemConstRawPtr rawcopypp) const { PPMonoidElemRawPtr rawpp(myMemMgr.alloc()); myAssign(rawpp, rawcopypp); // cannot throw return rawpp; }
RingElemRawPtr RingFpLogImpl::myNew(ConstRawPtr rawy) const { value_t* ans = static_cast<value_t*>(myMemMgr.alloc()); *ans = import(rawy); return RingElemRawPtr(ans); }
void test_markSweep(void) { MemPool* orgMemPool = gMemPool; void* tmp = HMD_ALLOC(2048); MemPool::initGMemPool(tmp, 2048); GC::initialize(); MemPool* pool = gMemPool; Object* o1 = Object::create(HC_StringBuffer, 20); MemCell* c2 = pool->alloc(40); Object* o3 = Object::create(HC_StringBuffer, 60); MemCell* c4 = pool->alloc(80); Object* o5 = Object::create(HC_StringBuffer, 100); Object* o6 = Object::create(HC_StringBuffer, 120); Object* o7 = Object::create(HC_StringBuffer, 80); MemCell* c8 = pool->alloc(100); Object* o9 = Object::create(HC_StringBuffer, 60); Object* o10 = Object::create(HC_StringBuffer, 40); // ObjectはGCObjectで、MemCellはGCObjectではない CPPUNIT_ASSERT(((MemCell*)o1)->isGCObject()); CPPUNIT_ASSERT(((MemCell*)o3)->isGCObject()); CPPUNIT_ASSERT(((MemCell*)o5)->isGCObject()); CPPUNIT_ASSERT(((MemCell*)o6)->isGCObject()); CPPUNIT_ASSERT(((MemCell*)o7)->isGCObject()); CPPUNIT_ASSERT(((MemCell*)o9)->isGCObject()); CPPUNIT_ASSERT(((MemCell*)o10)->isGCObject()); CPPUNIT_ASSERT(! c2->isGCObject()); CPPUNIT_ASSERT(! c4->isGCObject()); CPPUNIT_ASSERT(! c8->isGCObject()); // Object生成当初はマークされている CPPUNIT_ASSERT(o1->isMarked()); CPPUNIT_ASSERT(o3->isMarked()); CPPUNIT_ASSERT(o5->isMarked()); CPPUNIT_ASSERT(o6->isMarked()); CPPUNIT_ASSERT(o7->isMarked()); CPPUNIT_ASSERT(o9->isMarked()); CPPUNIT_ASSERT(o10->isMarked()); GC::unmark(); CPPUNIT_ASSERT(! o1->isMarked()); CPPUNIT_ASSERT(! o3->isMarked()); CPPUNIT_ASSERT(! o5->isMarked()); CPPUNIT_ASSERT(! o6->isMarked()); CPPUNIT_ASSERT(! o7->isMarked()); CPPUNIT_ASSERT(! o9->isMarked()); CPPUNIT_ASSERT(! o10->isMarked()); o3->m_mark(); o5->m_mark(); o6->m_mark(); o9->m_mark(); CPPUNIT_ASSERT(o3->isMarked()); CPPUNIT_ASSERT(o5->isMarked()); CPPUNIT_ASSERT(o6->isMarked()); CPPUNIT_ASSERT(o9->isMarked()); // 回収 GC::sweep(); // freeじゃないのはMemCellとmarkしたObjectとfinalize用Context int flag = 0; for (CellIterator itr = pool->begin(); itr < pool->end(); itr++) { MemCell* cell = *itr; if (! cell->m_bFree()) { if (cell == c2) { CPPUNIT_ASSERT((flag & 0x01) == 0); flag |= 0x01; } else if (cell == c4) { CPPUNIT_ASSERT((flag & 0x02) == 0); flag |= 0x02; } else if (cell == c8) { CPPUNIT_ASSERT((flag & 0x04) == 0); flag |= 0x04; } else if (cell == (MemCell*)o3) { CPPUNIT_ASSERT((flag & 0x08) == 0); flag |= 0x08; } else if (cell == (MemCell*)o5) { CPPUNIT_ASSERT((flag & 0x10) == 0); flag |= 0x10; } else if (cell == (MemCell*)o6) { CPPUNIT_ASSERT((flag & 0x20) == 0); flag |= 0x20; } else if (cell == (MemCell*)o9) { CPPUNIT_ASSERT((flag & 0x40) == 0); flag |= 0x40; } } } CPPUNIT_ASSERT(flag == 0x7f); GC::finalize(); gMemPool = orgMemPool; HMD_FREE(tmp); }
void Init(MemPool &pool, const Factor *factor) { lmstate = NULL; numWords = 1; lastWords = (const Factor**) pool.Allocate(sizeof(const Factor*)); lastWords[0] = factor; }
int32_t IndexFieldInc::idx2Txt(idx_dict_t* pdict) { if(NULL == pdict) { return 0; } char filename[PATH_MAX]; snprintf(filename, PATH_MAX, "%s/%s.txt", _idxPath, _fieldName); FILE* fp = fopen(filename, "wb"); if(NULL == fp) { return -1; } unsigned int pos = 0; MemPool cMemPool; idict_node_t* pNode = idx_dict_first(pdict, &pos); DocIdManager* pDoc = DocIdManager::getInstance(); DocIdManager::DeleteMap* del = pDoc->getDeleteMap(); int maxNum = 0, num = 0; DocListUnit* list = NULL; while(pNode) { IndexTerm* pIndexTerm = getTerm(&cMemPool, pNode->sign); if(NULL == pIndexTerm) { TERR("get %s %lu error\n", _fieldName, pNode->sign); fclose(fp); return -1; } const IndexTermInfo* pTermInfo = pIndexTerm->getTermInfo(); if(maxNum < pTermInfo->docNum) { if(list) delete [] list; maxNum = pTermInfo->docNum; list = new DocListUnit[maxNum]; } uint32_t docId; if(pTermInfo->maxOccNum > 0) { num = 0; while((docId = pIndexTerm->next()) < INVALID_DOCID) { if(del->isDel(docId)) continue; int32_t count; uint8_t* pocc = pIndexTerm->getOcc(count); for(int32_t i = 0; i < count; i++, num++) { list[num].doc_id = docId; list[num].occ = pocc[i]; } } } else { num = 0; while((docId = pIndexTerm->next()) < INVALID_DOCID) { if(del->isDel(docId)) continue; list[num].doc_id = docId; list[num++].occ = 0; } } if(num > 0) { fprintf(fp, "term:%lu docNum:%d\n", pNode->sign, num); if(pTermInfo->maxOccNum > 0) { for(int32_t i = 0; i < num; i++) { fprintf(fp, "%lu(%u) ", pDoc->getNid(list[i].doc_id), list[i].occ); } } else { for(int32_t i = 0; i < num; i++) { fprintf(fp, "%lu ", pDoc->getNid(list[i].doc_id)); } } fprintf(fp, "\n"); } cMemPool.reset(); pNode = idx_dict_next(pdict, &pos); } fclose(fp); if (list) delete [] list; return 0; }
void PPMonoidOvImpl::myDelete(RawPtr rawpp) const { myMemMgr.free(rawpp.myRawPtr()); }
RingElemRawPtr RingFpLogImpl::myNew() const { value_t* ans = static_cast<value_t*>(myMemMgr.alloc()); *ans = 0; return RingElemRawPtr(ans); }
int32_t SearcherWorker::run() { const char *pureString = NULL; uint32_t pureSize = 0; char *resData = NULL; uint32_t resSize = 0; char *resDetailData = NULL; int32_t resDetailSize = 0; int32_t ret = 0; MemPool *memPool = NULL; int64_t *pNid = NULL; commdef::ClusterResult *pClusterResult = NULL; queryparser::QueryRewriterResult *pQRWResult = NULL; queryparser::QPResult *pQueryResult = NULL; SearchResult *pSearchResult = NULL; statistic::StatisticResult *pStatisticResult = NULL; sort_framework::SortResult *pSortResult = NULL; ResultSerializer resultSerial; FRAMEWORK::Context context; FILE *pOutput = NULL; //check session status FRAMEWORK::session_status_t status = _session.getStatus(); if (status == FRAMEWORK::ss_timeout) { handleTimeout(); return KS_SUCCESS; } //get query infomation FRAMEWORK::Query &query = _session.getQuery(); pureSize = query.getPureQuerySize(); pureString = query.getPureQueryData(); if (!pureString || pureSize == 0) { _session.setStatus(FRAMEWORK::ss_error); _session.response(); return KS_EFAILED; } //set LogInfo level _session._logInfo._eRole = FRAMEWORK::sr_simple; //get MemPool from factory memPool = _memFactory.make((uint64_t)(getOwner())); if (memPool == NULL) { TWARN("Make mem pool failed!"); return KS_EFAILED; } //create memory pool monitor MemMonitor memMonitor(memPool, _memLimit); memPool->setMonitor(&memMonitor); memMonitor.enableException(); //initialize context class context.setMemPool(memPool); //initialize format processor _formatProcessor.init(memPool); //Deal with search proccess do{ if(_session.isHttp()){ pQRWResult = NEW(memPool, queryparser::QueryRewriterResult)(); if (pQRWResult == NULL) { TWARN("SEARCHER: new Result no mem"); _session.setStatus(FRAMEWORK::ss_error); break; } } pQueryResult = NEW(memPool, queryparser::QPResult)(memPool); pSearchResult = NEW(memPool, SearchResult); pStatisticResult = NEW(memPool, statistic::StatisticResult); pSortResult = NEW(memPool, sort_framework::SortResult)(memPool); if(unlikely(!pQueryResult || !pSearchResult || !pStatisticResult || !pSortResult)) { TWARN("SEARCHER: new Result no mem"); _session.setStatus(FRAMEWORK::ss_error); break; } //add queryrewrite process if(_session.isHttp()){ ret = _qrewriter.doRewrite(&context, pureString, pureSize, pQRWResult); if (timeoutCheck && (_timeout > 0) && (_session.getLatencyTime() > _timeout)) { _session.setStatus(FRAMEWORK::ss_timeout); TWARN("SEARCHER: qrewriter.doRewrite function over time. query is %s", pureString); break; } if (unlikely(ret != KS_SUCCESS)) { _session.setStatus(FRAMEWORK::ss_error); TWARN("qrewriter.doRewrite function error. query is %s", pureString); break; } pureString = pQRWResult->getRewriteQuery(); } //end add ret = _qp.doParse(&context, pQueryResult, pureString); if (timeoutCheck && (_timeout > 0) && (_session.getLatencyTime() > _timeout)) { _session.setStatus(FRAMEWORK::ss_timeout); TWARN("SEARCHER: qp.doParse function over time. query is %s", pureString); break; } if (unlikely(ret != KS_SUCCESS)){ TWARN("SEARCHER: queryparser doParse function error. query is %s", pureString); _session.setStatus(FRAMEWORK::ss_error); break; } // cache命中情况下, mempool reset时调用CacheResult析构函数,释放命中的节点, // 否则sortResult对节点内存的引用失效,变为野指针(bug#118631) { ret = _is.doQuery(&context, pQueryResult, &_sort, pSearchResult); if (timeoutCheck && (_timeout > 0) && (_session.getLatencyTime() > _timeout)) { _session.setStatus(FRAMEWORK::ss_timeout); TWARN("SEARCHER: is.doQuery function over time. query is %s", pureString); break; } if (unlikely(ret != KS_SUCCESS)){ TWARN("SEARCHER: search doQuery function error. query is %s", pureString); _session.setStatus(FRAMEWORK::ss_error); break; } ret = _stat.doStatisticOnSearcher(&context, *(pQueryResult->getParam()), pSearchResult, pStatisticResult); if (timeoutCheck && (_timeout > 0) && (_session.getLatencyTime() > _timeout)) { _session.setStatus(FRAMEWORK::ss_timeout); TWARN("SEARCHER: doStatisticOnSearcher function over time. query is %s", pureString); break; } if (unlikely(ret != KS_SUCCESS)){ TWARN("SEARCHER: statistic doStatisticOnSearcher function error. query is %s", pureString); _session.setStatus(FRAMEWORK::ss_error); break; } ret = _sort.doProcess(context, *(pQueryResult->getParam()), *pSearchResult, *pSortResult); if (timeoutCheck && (_timeout > 0) && (_session.getLatencyTime() > _timeout)) { _session.setStatus(FRAMEWORK::ss_timeout); TWARN("SEARCHER: sort.doProcess function over time. query is %s", pureString); break; } if (unlikely(ret)) { TWARN("SEARCHER: sort doProcess function error. query is %s", pureString); _session.setStatus(FRAMEWORK::ss_error); break; } } pNid = NULL; //get docs return number int32_t num = pSortResult->getNidList(pNid); pClusterResult = NEW(memPool, commdef::ClusterResult)(); if ( NULL == pClusterResult ){ TWARN("SEARCHER: malloc from memPool failed "); _session.setStatus(FRAMEWORK::ss_error); break; } memset(pClusterResult, 0x0, sizeof(commdef::ClusterResult)); pClusterResult->_nDocsFound = pSortResult->getDocsFound();//pSearchResult->nDocFound; pClusterResult->_nEstimateDocsFound = pSortResult->getEstimateDocsFound();//pSearchResult->nEstimateDocFound; pClusterResult->_nDocsSearch = pSearchResult->nDocSearch; pClusterResult->_nDocsReturn = num; pClusterResult->_nDocsRestrict = pSearchResult->nEstimateDocFound;//pSearchResult->nDocFound; pClusterResult->_pStatisticResult = pStatisticResult; pClusterResult->_pSortResult = pSortResult; pClusterResult->_pQPResult = pQueryResult; pClusterResult->_ppDocuments = NULL; if(_session.isHttp() && _detail){ if(!pClusterResult->_nDocsReturn){ break; } char* pid = NULL; uint32_t pid_size = 0; ret = get_nid_str(pNid, num, memPool, &pid, &pid_size); if(KS_SUCCESS != ret){ _session.setStatus(FRAMEWORK::ss_error); break; } ret = getDetailInfo(pid, pid_size, pureString, &resDetailData, &resDetailSize); if(KS_SUCCESS != ret){ _session.setStatus(FRAMEWORK::ss_error); break; } if(timeoutCheck && _timeout>0 && _session.getLatencyTime()>_timeout){ _session.setStatus(FRAMEWORK::ss_timeout); break; } if (!translateV3(resDetailData, pClusterResult->_ppDocuments, (uint32_t &)pClusterResult->_nDocsReturn, memPool)) { _session.setStatus(FRAMEWORK::ss_error); break; } } } while (0); if(resDetailData)std::free(resDetailData); if(_session.isHttp() && _detail){ //fromat result get_outfmt_type(pureString, pureSize); result_container_t container; container.pClusterResult = pClusterResult; container.cost = _session.getLatencyTime(); if(_formatProcessor.frmt(_ofmt_type, container, &resData , &resSize) < 0){ TERR("FORMATRESULT: format_processor process error!"); _session.setStatus(FRAMEWORK::ss_error); } } else{ //serialize search result ret = resultSerial.serialClusterResult(pClusterResult, resData, resSize, "Z"); if (ret != KS_SUCCESS) { _session.setStatus(FRAMEWORK::ss_error); } } //recycle mem pool context.getMemPool()->reset(); _session.setResponseData(resData, resSize); _session.response(); return KS_SUCCESS; }
RingElemRawPtr RingFpLogImpl::myNew(const BigInt& N) const { value_t* ans = static_cast<value_t*>(myMemMgr.alloc()); *ans = myImpl.myReduce(N); return RingElemRawPtr(ans); }
PPMonoidElemRawPtr PPMonoidOvImpl::myNew() const { PPMonoidElemRawPtr rawpp(myMemMgr.alloc()); myAssignOne(rawpp); // cannot throw return rawpp; }
void RingFpLogImpl::myDelete(RawPtr rawx) const { myMemMgr.free(rawx.myRawPtr()); }
void test1() { MemPool mp; void* p = mp.alloc(100); mp.printInfo(); p = mp.alloc(100); mp.printInfo(); mp.free(p); mp.printInfo(); void* p1 = mp.alloc(100); mp.printInfo(); void* p2 = mp.alloc(100); mp.printInfo(); void* p3 = mp.alloc(100); mp.printInfo(); void* p4 = mp.alloc(100); mp.printInfo(); void* p5 = mp.alloc(256); mp.printInfo(); void* p6 = mp.alloc(257); mp.printInfo(); mp.free(p1); mp.printInfo(); mp.free(p2); mp.printInfo(); mp.free(p3); mp.printInfo(); mp.free(p4); mp.printInfo(); }