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);
}
