size_t inventory_entry::get_available_count() const { if( is_item() && get_stack_size() == 1 ) { return get_item().count_by_charges() ? get_item().charges : 1; } else { return get_stack_size(); } }
int main() { int n; stack tmp = { 0, 0 }; stack *s = &tmp; init_stack(s); printf("input int:"); while (scanf("%d", &n) != EOF) { if (n < 0) { int v = pop_stack(s); printf("pop() -> v:%d,num:%d,size:%d\n", v, get_stack_datanum(s), get_stack_size(s)); } else if (n > 0) { push_stack(s, n); printf("push() -> num:%d,size:%d\n", get_stack_datanum(s), get_stack_size(s)); } else { break; } printf("input int:"); } printf("over...\n"); release_stack(s); //释放内存 return 0; }
void recycle_thread(thread_id_type thrd) { std::ptrdiff_t stacksize = thrd->get_stack_size(); if (stacksize == get_stack_size(thread_stacksize_small)) { thread_heap_small_.push_front(thrd); } else if (stacksize == get_stack_size(thread_stacksize_medium)) { thread_heap_medium_.push_front(thrd); } else if (stacksize == get_stack_size(thread_stacksize_large)) { thread_heap_large_.push_front(thrd); } else if (stacksize == get_stack_size(thread_stacksize_huge)) { thread_heap_huge_.push_front(thrd); } else { switch(stacksize) { case thread_stacksize_small: thread_heap_small_.push_front(thrd); break; case thread_stacksize_medium: thread_heap_medium_.push_front(thrd); break; case thread_stacksize_large: thread_heap_large_.push_front(thrd); break; case thread_stacksize_huge: thread_heap_huge_.push_front(thrd); break; default: HPX_ASSERT(false); break; } } }
int parse_callchain_record_opt(const char *arg) { char *tok, *name, *saveptr = NULL; char *buf; int ret = -1; /* We need buffer that we know we can write to. */ buf = malloc(strlen(arg) + 1); if (!buf) return -ENOMEM; strcpy(buf, arg); tok = strtok_r((char *)buf, ",", &saveptr); name = tok ? : (char *)buf; do { /* Framepointer style */ if (!strncmp(name, "fp", sizeof("fp"))) { if (!strtok_r(NULL, ",", &saveptr)) { callchain_param.record_mode = CALLCHAIN_FP; ret = 0; } else pr_err("callchain: No more arguments " "needed for --call-graph fp\n"); break; #ifdef HAVE_DWARF_UNWIND_SUPPORT /* Dwarf style */ } else if (!strncmp(name, "dwarf", sizeof("dwarf"))) { const unsigned long default_stack_dump_size = 8192; ret = 0; callchain_param.record_mode = CALLCHAIN_DWARF; callchain_param.dump_size = default_stack_dump_size; tok = strtok_r(NULL, ",", &saveptr); if (tok) { unsigned long size = 0; ret = get_stack_size(tok, &size); callchain_param.dump_size = size; } #endif /* HAVE_DWARF_UNWIND_SUPPORT */ } else { pr_err("callchain: Unknown --call-graph option " "value: %s\n", arg); break; } } while (0); free(buf); return ret; }
int main() { int ar[] = {1,2,3,4}; int idx ; void *ret; struct stack *st; st = stack_constructor(sizeof(int), CAPACITY); for (idx = 0; idx < sizeof(ar)/sizeof(ar[0]); idx++ ) { push( st, &ar[idx],sizeof(int)); } /*test get_stack_top */ ret = get_stack_top(st); printf("get_stack_top : %d\n",*(int *)ret); /*test get_stack_size()*/ printf("current get_stack_size : %d\n",get_stack_size(st)); /*test pop() */ pop(st); ret = get_stack_top(st); printf("get_stack_top : %d\n",*(int *)ret); /*test get_stack_empty()*/ pop(st); pop(st); pop(st); pop(st); printf("get_stack_empty : %d \n",get_stack_empty(st)); ret = get_stack_top(st); if (NULL == ret) { printf("It empty now! \n"); } else { printf("get_stack_top : %d\n",*(int *)ret); } /*test stack_destroy()*/ stack_destroy(st); printf("clean up ~ \n"); return 0; }
int perf_callchain_config(const char *var, const char *value) { char *endptr; if (prefixcmp(var, "call-graph.")) return 0; var += sizeof("call-graph.") - 1; if (!strcmp(var, "record-mode")) return parse_callchain_record_opt(value, &callchain_param); if (!strcmp(var, "dump-size")) { unsigned long size = 0; int ret; ret = get_stack_size(value, &size); callchain_param.dump_size = size; return ret; } if (!strcmp(var, "print-type")) return parse_callchain_mode(value); if (!strcmp(var, "order")) return parse_callchain_order(value); if (!strcmp(var, "sort-key")) return parse_callchain_sort_key(value); if (!strcmp(var, "threshold")) { callchain_param.min_percent = strtod(value, &endptr); if (value == endptr) { pr_err("Invalid callchain threshold: %s\n", value); return -1; } } if (!strcmp(var, "print-limit")) { callchain_param.print_limit = strtod(value, &endptr); if (value == endptr) { pr_err("Invalid callchain print limit: %s\n", value); return -1; } } return 0; }
int main(int argc, char *argv[]) { __stack *s = init_stack(); int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; int i; for(i=0; i<9; i++) { push(s, array+i); } printf("stack size is %zu\n", get_stack_size(s)); while(!is_stack_empty(s)) { int *p = (int *)pop(s); printf("%d\n", *p); } destroy_stack(s); return 0; }
int perf_callchain_config(const char *var, const char *value) { char *endptr; if (prefixcmp(var, "call-graph.")) return 0; var += sizeof("call-graph.") - 1; if (!strcmp(var, "record-mode")) return parse_callchain_record_opt(value, &callchain_param); #ifdef HAVE_DWARF_UNWIND_SUPPORT if (!strcmp(var, "dump-size")) { unsigned long size = 0; int ret; ret = get_stack_size(value, &size); callchain_param.dump_size = size; return ret; } #endif if (!strcmp(var, "print-type")) return parse_callchain_mode(value); if (!strcmp(var, "order")) return parse_callchain_order(value); if (!strcmp(var, "sort-key")) return parse_callchain_sort_key(value); if (!strcmp(var, "threshold")) { callchain_param.min_percent = strtod(value, &endptr); if (value == endptr) return -1; } if (!strcmp(var, "print-limit")) { callchain_param.print_limit = strtod(value, &endptr); if (value == endptr) return -1; } return 0; }
void create_thread_object(threads::thread_id_type& thrd, threads::thread_init_data& data, thread_state_enum state, Lock& lk) { HPX_ASSERT(lk.owns_lock()); HPX_ASSERT(data.stacksize != 0); std::ptrdiff_t stacksize = data.stacksize; std::list<thread_id_type>* heap = 0; if (stacksize == get_stack_size(thread_stacksize_small)) { heap = &thread_heap_small_; } else if (stacksize == get_stack_size(thread_stacksize_medium)) { heap = &thread_heap_medium_; } else if (stacksize == get_stack_size(thread_stacksize_large)) { heap = &thread_heap_large_; } else if (stacksize == get_stack_size(thread_stacksize_huge)) { heap = &thread_heap_huge_; } else { switch(stacksize) { case thread_stacksize_small: heap = &thread_heap_small_; break; case thread_stacksize_medium: heap = &thread_heap_medium_; break; case thread_stacksize_large: heap = &thread_heap_large_; break; case thread_stacksize_huge: heap = &thread_heap_huge_; break; default: break; } } HPX_ASSERT(heap); // Check for an unused thread object. if (!heap->empty()) { // Take ownership of the thread object and rebind it. thrd = heap->front(); heap->pop_front(); thrd->rebind(data, state); } else { hpx::util::unlock_guard<Lock> ull(lk); // Allocate a new thread object. thrd = threads::thread_data::create( data, memory_pool_, state); } }
static int __parse_callchain_report_opt(const char *arg, bool allow_record_opt) { char *tok; char *endptr, *saveptr = NULL; bool minpcnt_set = false; bool record_opt_set = false; bool try_stack_size = false; callchain_param.enabled = true; symbol_conf.use_callchain = true; if (!arg) return 0; while ((tok = strtok_r((char *)arg, ",", &saveptr)) != NULL) { if (!strncmp(tok, "none", strlen(tok))) { callchain_param.mode = CHAIN_NONE; callchain_param.enabled = false; symbol_conf.use_callchain = false; return 0; } if (!parse_callchain_mode(tok) || !parse_callchain_order(tok) || !parse_callchain_sort_key(tok) || !parse_callchain_value(tok)) { /* parsing ok - move on to the next */ try_stack_size = false; goto next; } else if (allow_record_opt && !record_opt_set) { if (parse_callchain_record(tok, &callchain_param)) goto try_numbers; /* assume that number followed by 'dwarf' is stack size */ if (callchain_param.record_mode == CALLCHAIN_DWARF) try_stack_size = true; record_opt_set = true; goto next; } try_numbers: if (try_stack_size) { unsigned long size = 0; if (get_stack_size(tok, &size) < 0) return -1; callchain_param.dump_size = size; try_stack_size = false; } else if (!minpcnt_set) { /* try to get the min percent */ callchain_param.min_percent = strtod(tok, &endptr); if (tok == endptr) return -1; minpcnt_set = true; } else { /* try print limit at last */ callchain_param.print_limit = strtoul(tok, &endptr, 0); if (tok == endptr) return -1; } next: arg = NULL; } if (callchain_register_param(&callchain_param) < 0) { pr_err("Can't register callchain params\n"); return -1; } return 0; }
void save_stack_info(bool main) { g_stack_info_init = true; g_stack_size = get_stack_size(main); char x; g_stack_base = reinterpret_cast<size_t>(&x); }