/****************************************************************//** Inserts the trx handle in the trx system trx list in the right position. The list is sorted on the trx id so that the biggest id is at the list start. This function is used at the database startup to insert incomplete transactions to the list. */ static void trx_list_insert_ordered( /*====================*/ trx_t* trx) /*!< in: trx handle */ { trx_t* trx2; ut_ad(mutex_own(&kernel_mutex)); trx2 = UT_LIST_GET_FIRST(trx_sys->trx_list); while (trx2 != NULL) { if (ut_dulint_cmp(trx->id, trx2->id) >= 0) { ut_ad(ut_dulint_cmp(trx->id, trx2->id) == 1); break; } trx2 = UT_LIST_GET_NEXT(trx_list, trx2); } if (trx2 != NULL) { trx2 = UT_LIST_GET_PREV(trx_list, trx2); if (trx2 == NULL) { UT_LIST_ADD_FIRST(trx_list, trx_sys->trx_list, trx); } else { UT_LIST_INSERT_AFTER(trx_list, trx_sys->trx_list, trx2, trx); } } else { UT_LIST_ADD_LAST(trx_list, trx_sys->trx_list, trx); } }
void buf_flush_insert_sorted_into_flush_list( /*====================================*/ buf_block_t* block) /* in: block which is modified */ { buf_block_t* prev_b; buf_block_t* b; ut_ad(mutex_own(&(buf_pool->mutex))); prev_b = NULL; b = UT_LIST_GET_FIRST(buf_pool->flush_list); while (b && (ut_dulint_cmp(b->oldest_modification, block->oldest_modification) > 0)) { prev_b = b; b = UT_LIST_GET_NEXT(flush_list, b); } if (prev_b == NULL) { UT_LIST_ADD_FIRST(flush_list, buf_pool->flush_list, block); } else { UT_LIST_INSERT_AFTER(flush_list, buf_pool->flush_list, prev_b, block); } ut_ad(buf_flush_validate_low()); }
mem_block_t* mem_heap_add_block( /*===============*/ /* out: created block, NULL if did not succeed */ mem_heap_t* heap, /* in: memory heap */ ulint n) /* in: number of bytes user needs */ { mem_block_t* block; mem_block_t* new_block; ulint new_size; ut_ad(mem_heap_check(heap)); block = UT_LIST_GET_LAST(heap->base); /* We have to allocate a new block. The size is always at least doubled until the standard size is reached. After that the size stays the same, except in cases where the caller needs more space. */ new_size = 2 * mem_block_get_len(block); if (heap->type != MEM_HEAP_DYNAMIC) { /* From the buffer pool we allocate buffer frames */ ut_a(n <= MEM_MAX_ALLOC_IN_BUF); if (new_size > MEM_MAX_ALLOC_IN_BUF) { new_size = MEM_MAX_ALLOC_IN_BUF; } } else if (new_size > MEM_BLOCK_STANDARD_SIZE) { new_size = MEM_BLOCK_STANDARD_SIZE; } if (new_size < n) { new_size = n; } new_block = mem_heap_create_block(heap, new_size, NULL, heap->type, heap->file_name, heap->line); if (new_block == NULL) { return(NULL); } /* Add the new block as the last block */ UT_LIST_INSERT_AFTER(list, heap->base, block, new_block); return(new_block); }
void OSEventThread::addTimer(event_timer_t * ev) { //event_timer_t * list; //if (ev->timespan > 0) { // // add to timer list // list = UT_LIST_GET_FIRST(mTimerList); // ev->timeout = ev->timespan + OS::GetTickCount(); // // keep list sorted // while ( (list) && (list->timeout < ev->timeout )) { // list = UT_LIST_GET_NEXT(watchNode,ev); // } // // list now points to the first event older than ev // UT_LIST_INSERT_AFTER(watchNode,mTimerList,list,ev); //} TRACE("~~~~ +addTimer (%d) ~~~~\n",ev->timespan); event_timer_t * tev = UT_LIST_GET_FIRST(mTimerList); event_timer_t * prev; ev->timeout = ev->timespan + OS::GetTickCount(); if(tev == NULL || tev->timeout > ev->timeout){ UT_LIST_ADD_FIRST(watchNode,mTimerList,ev); TRACE("~~~~ -addWatch ,timeout(%d),count(%d)~~~~\n",ev->timeout,mTimerList.count); return; //return true; } do{ prev = tev; tev = UT_LIST_GET_NEXT(watchNode,prev); }while (tev && tev->timeout < ev->timeout); UT_LIST_INSERT_AFTER(watchNode,mTimerList,prev,ev); TRACE("~~~~ -addTimer ,timeout(%d),count(%d)~~~~\n",ev->timeout,mTimerList.count); // return true; }
bool OSEventThread::addWatch(event_req_t * ev) { TRACE("~~~~ +addWatch (%d) ~~~~\n",ev->fd); event_req_t * tev = UT_LIST_GET_FIRST(mWatchList); event_req_t * prev; FD_SET(ev->fd, &mReadFds); if (ev->fd >= mMaxfFd) mMaxfFd = ev->fd+1; if(tev == NULL || tev->fd > ev->fd){ UT_LIST_ADD_FIRST(watchNode,mWatchList,ev); TRACE("~~~~ -addWatch ,mMaxfFd(%d),count(%d)~~~~\n",mMaxfFd,mWatchList.count); return true; } do{ prev = tev; tev = UT_LIST_GET_NEXT(watchNode,prev); }while (tev && tev->fd < ev->fd); UT_LIST_INSERT_AFTER(watchNode,mWatchList,prev,ev); TRACE("~~~~ -addWatch ,mMaxfFd(%d),count(%d)~~~~\n",mMaxfFd,mWatchList.count); return true; }
/********************************************************************** Adds a block to the LRU list. */ UNIV_INLINE void buf_LRU_add_block_low( /*==================*/ buf_block_t* block, /* in: control block */ ibool old) /* in: TRUE if should be put to the old blocks in the LRU list, else put to the start; if the LRU list is very short, the block is added to the start, regardless of this parameter */ { ulint cl; ut_ad(buf_pool); ut_ad(block); ut_ad(mutex_own(&(buf_pool->mutex))); ut_a(block->state == BUF_BLOCK_FILE_PAGE); ut_a(!block->in_LRU_list); block->old = old; cl = buf_pool_clock_tic(); if (srv_use_awe && block->frame) { /* Add to the list of mapped pages; for simplicity we always add to the start, even if the user would have set 'old' TRUE */ UT_LIST_ADD_FIRST(awe_LRU_free_mapped, buf_pool->awe_LRU_free_mapped, block); } if (!old || (UT_LIST_GET_LEN(buf_pool->LRU) < BUF_LRU_OLD_MIN_LEN)) { UT_LIST_ADD_FIRST(LRU, buf_pool->LRU, block); block->LRU_position = cl; block->freed_page_clock = buf_pool->freed_page_clock; } else { UT_LIST_INSERT_AFTER(LRU, buf_pool->LRU, buf_pool->LRU_old, block); buf_pool->LRU_old_len++; /* We copy the LRU position field of the previous block to the new block */ block->LRU_position = (buf_pool->LRU_old)->LRU_position; } block->in_LRU_list = TRUE; if (UT_LIST_GET_LEN(buf_pool->LRU) > BUF_LRU_OLD_MIN_LEN) { ut_ad(buf_pool->LRU_old); /* Adjust the length of the old block list if necessary */ buf_LRU_old_adjust_len(); } else if (UT_LIST_GET_LEN(buf_pool->LRU) == BUF_LRU_OLD_MIN_LEN) { /* The LRU list is now long enough for LRU_old to become defined: init it */ buf_LRU_old_init(); } }