static void read_stdin(t_env *env) { char buffer[20]; int rd; ft_memset(buffer, 0, 20); rd = read(0, buffer, 20); if (rd == 1 && buffer[0] == 27) error_quit(NULL); else if (rd == 1 && buffer[0] == 10) return_selected(env); else if ((rd == 1 && buffer[0] == 127) || !ft_strcmp(buffer, env->key_code_delete)) delete_current(env); else if (rd == 1 && buffer[0] == ' ') { if (env->curr) env->curr->item->selected = !env->curr->item->selected; } else if (!ft_strcmp(buffer, env->key_code_down)) move_down(env); else if (!ft_strcmp(buffer, env->key_code_up)) move_up(env); else if (!ft_strcmp(buffer, env->key_code_left)) move_left(env); else if (!ft_strcmp(buffer, env->key_code_right)) move_right(env); }
twl::~twl() { current = head->next; while (sum) delete_current(); delete head; }
void _lru_process_waiters(cache_t *c) { cache_lru_t *cp = (cache_lru_t *)c->fn.priv; lru_page_wait_t *pw = NULL; cache_cond_t *cache_cond; ex_off_t bytes_free, bytes_needed; if (stack_size(cp->pending_free_tasks) > 0) { //**Check on pending free tasks 1st while ((cache_cond = (cache_cond_t *)pop(cp->pending_free_tasks)) != NULL) { log_printf(15, "waking up pending task cache_cond=%p stack_size left=%d\n", cache_cond, stack_size(cp->pending_free_tasks)); apr_thread_cond_signal(cache_cond->cond); //** Wake up the paused thread } // return; } if (stack_size(cp->waiting_stack) > 0) { //** Also handle the tasks waiting for flushes to complete bytes_free = _lru_max_bytes(c) - cp->bytes_used; move_to_top(cp->waiting_stack); pw = get_ele_data(cp->waiting_stack); bytes_needed = pw->bytes_needed; while ((bytes_needed <= bytes_free) && (pw != NULL)) { bytes_free -= bytes_needed; delete_current(cp->waiting_stack, 1, 0); log_printf(15, "waking up waiting stack pw=%d\n", pw); apr_thread_cond_signal(pw->cond); //** Wake up the paused thread //** Get the next one if available pw = get_ele_data(cp->waiting_stack); bytes_needed = (pw == NULL) ? bytes_free + 1 : pw->bytes_needed; } } }
int resource_list_pending_activate(Resource_list_t *rl, char *rid, Resource_t *r) { int slot; char *prid; apr_thread_mutex_lock(rl->lock); move_to_top(rl->pending); slot = -1; while ((prid = get_ele_data(rl->pending)) != NULL) { log_printf(0, "rid=%s prid=%s\n", rid, prid); if (strcmp(rid, prid) == 0) { delete_current(rl->pending, 0, 0); slot = _resource_list_insert(rl, r); break; } move_down(rl->pending); } apr_thread_mutex_unlock(rl->lock); if (slot == -1) { log_printf(0, "No pending RID matches %s\n", rid); } return(slot); }
int _lru_free_mem(cache_t *c, segment_t *pseg, ex_off_t bytes_to_free) { cache_lru_t *cp = (cache_lru_t *)c->fn.priv; cache_segment_t *s; cache_page_t *p; page_lru_t *lp; Stack_ele_t *ele; apr_thread_mutex_t *plock; ex_off_t total_bytes, pending_bytes; int gotlock, count, bits, err; total_bytes = 0; err = 0; log_printf(15, "START seg=" XIDT " bytes_to_free=" XOT " bytes_used=" XOT " stack_size=%d\n", segment_id(pseg), bytes_to_free, cp->bytes_used, stack_size(cp->stack)); move_to_bottom(cp->stack); ele = get_ptr(cp->stack); while ((total_bytes < bytes_to_free) && (ele != NULL) && (err == 0)) { p = (cache_page_t *)get_stack_ele_data(ele); lp = (page_lru_t *)p->priv; plock = p->seg->lock; gotlock = apr_thread_mutex_trylock(plock); if ((gotlock == APR_SUCCESS) || (p->seg == pseg)) { bits = atomic_get(p->bit_fields); if ((bits & C_TORELEASE) == 0) { //** Skip it if already flagged for removal count = atomic_get(p->access_pending[CACHE_READ]) + atomic_get(p->access_pending[CACHE_WRITE]) + atomic_get(p->access_pending[CACHE_FLUSH]); if (count == 0) { //** No one is using it s = (cache_segment_t *)p->seg->priv; if ((bits & C_ISDIRTY) == 0) { //** Don't have to flush it total_bytes += s->page_size; log_printf(15, "lru_free_mem: freeing page seg=" XIDT " p->offset=" XOT " bits=%d\n", segment_id(p->seg), p->offset, bits); list_remove(s->pages, &(p->offset), p); //** Have to do this here cause p->offset is the key var delete_current(cp->stack, 1, 0); if (p->data[0].ptr) free(p->data[0].ptr); if (p->data[1].ptr) free(p->data[1].ptr); free(lp); } else { //** Got to flush the page first err = 1; } } else { err = 1; } } if (gotlock == APR_SUCCESS) apr_thread_mutex_unlock(plock); } else { err = 1; } if ((total_bytes < bytes_to_free) && (err == 0)) ele = get_ptr(cp->stack); } cp->bytes_used -= total_bytes; pending_bytes = bytes_to_free - total_bytes; log_printf(15, "END seg=" XIDT " bytes_to_free=" XOT " pending_bytes=" XOT " bytes_used=" XOT "\n", segment_id(pseg), bytes_to_free, pending_bytes, cp->bytes_used); return(pending_bytes); }
void lru_pages_destroy(cache_t *c, cache_page_t **page, int n_pages, int remove_from_segment) { cache_lru_t *cp = (cache_lru_t *)c->fn.priv; cache_segment_t *s; page_lru_t *lp; cache_page_t *p; // cache_cond_t *cache_cond; int i; int cr, cw, cf, count; cache_lock(c); log_printf(15, " START cp->bytes_used=" XOT "\n", cp->bytes_used); for (i=0; i<n_pages; i++) { p = page[i]; s = (cache_segment_t *)p->seg->priv; cr = atomic_get(p->access_pending[CACHE_READ]); cw = atomic_get(p->access_pending[CACHE_WRITE]); cf = atomic_get(p->access_pending[CACHE_FLUSH]); count = cr +cw + cf; // cache_cond = (cache_cond_t *)pigeon_coop_hole_data(&(p->cond_pch)); // if (cache_cond == NULL) { //** No one listening so free normally if (count == 0) { //** No one is listening log_printf(15, "lru_pages_destroy i=%d p->offset=" XOT " seg=" XIDT " remove_from_segment=%d limbo=%d\n", i, p->offset, segment_id(p->seg), remove_from_segment, cp->limbo_pages); cp->bytes_used -= s->page_size; lp = (page_lru_t *)p->priv; if (lp->ele != NULL) { move_to_ptr(cp->stack, lp->ele); delete_current(cp->stack, 0, 0); } if (remove_from_segment == 1) { s = (cache_segment_t *)p->seg->priv; list_remove(s->pages, &(p->offset), p); //** Have to do this here cause p->offset is the key var } if (p->data[0].ptr) free(p->data[0].ptr); if (p->data[1].ptr) free(p->data[1].ptr); free(lp); } else { //** Someone is listening so trigger them and also clear the bits so it will be released atomic_set(p->bit_fields, C_TORELEASE); log_printf(15, "lru_pages_destroy i=%d p->offset=" XOT " seg=" XIDT " remove_from_segment=%d cr=%d cw=%d cf=%d limbo=%d\n", i, p->offset, segment_id(p->seg), remove_from_segment, cr, cw, cf, cp->limbo_pages); } } log_printf(15, " AFTER LOOP cp->bytes_used=" XOT "\n", cp->bytes_used); log_printf(15, " END cp->bytes_used=" XOT "\n", cp->bytes_used); cache_unlock(c); }
/* Menu-specific shortcut handler. Returns code that specifies both taken * actions and what should be done next. */ static KHandlerResponse trash_khandler(FileView *view, menu_data_t *m, const wchar_t keys[]) { if(wcscmp(keys, L"r") == 0) { return restore_current(m); } else if(wcscmp(keys, L"dd") == 0) { return delete_current(m); } return KHR_UNHANDLED; }
int lru_pages_release(cache_t *c, cache_page_t **page, int n_pages) { cache_lru_t *cp = (cache_lru_t *)c->fn.priv; cache_segment_t *s; page_lru_t *lp; cache_page_t *p; int bits, i; cache_lock(c); for (i=0; i<n_pages; i++) { p = page[i]; bits = atomic_get(p->bit_fields); log_printf(15, "seg=" XIDT " p->offset=" XOT " bits=%d bytes_used=" XOT "\n", segment_id(p->seg), p->offset, bits, cp->bytes_used); if ((bits & C_TORELEASE) > 0) { log_printf(15, "DESTROYING seg=" XIDT " p->offset=" XOT " bits=%d bytes_used=" XOT "cache_pages=%d\n", segment_id(p->seg), p->offset, bits, cp->bytes_used, stack_size(cp->stack)); s = (cache_segment_t *)p->seg->priv; lp = (page_lru_t *)p->priv; cp->bytes_used -= s->page_size; if (lp->ele != NULL) { move_to_ptr(cp->stack, lp->ele); delete_current(cp->stack, 0, 0); } else { cp->limbo_pages--; log_printf(15, "seg=" XIDT " limbo page p->offset=" XOT " limbo=%d\n", segment_id(p->seg), p->offset, cp->limbo_pages); } if (p->offset > -1) { list_remove(s->pages, &(p->offset), p); //** Have to do this here cause p->offset is the key var } if (p->data[0].ptr) free(p->data[0].ptr); if (p->data[1].ptr) free(p->data[1].ptr); free(lp); } } //** Now check if we can handle some waiters _lru_process_waiters(c); cache_unlock(c); return(0); }
void twl::locate(int x) { node *p1, *p2; int count = 0,flag = 0; p1 = p2 = head; while (count < sum) { p1 = p1->next; if (x == p1->data) { flag = 1; break; } p2 = p2->prior; if (x == p2->data) { flag = 2; break; } count += 2; } if (1 == flag) { p1->freq += 1; // sort_by_freq(); /* p2 = head->next; while (p2->freq > p1->freq && p2 != head) { p2 = p2->next; } if (p2 != head) { p2 = p2->prior; p1->next->prior = p1->prior; p1->prior->next = p1->next; p1->next = p2->next; p1->next->prior = p1; p2->next = p1; p1->prior = p2; }*/ current = head->next; while (current->freq > p1->freq && current != head) { current = current->next; } if (current != head) { current = current->prior; add(p1->data); current->freq = p1->freq; current = p1; delete_current(); } } else if (2 == flag) { p2->freq += 1; // sort_by_freq(); current = head->next; while (current->freq > p2->freq && current != head) { current = current->next; } if (current != head) { current = current->prior; add(p2->data); current->freq = p2->freq; current = p2; delete_current(); } } }