IDEBool IDEAPI IDERunYourSelfArgv // COMPILE A PROGRAM ( IDEDllHdl hdl, // - handle for this instantiation int argc, // - # of arguments char **args, // - argument vector IDEBool* fatal_error ) // - addr[fatality indication] { //**************************** // Do a compile of a file //**************************** jmp_buf env; char infile[_MAX_PATH]; // - input file name char outfile[4 + _MAX_PATH]; // - output file name (need room for "-fo=") char **argv = NULL; int ret; TBreak(); // clear any pending IDEStopRunning's *fatal_error = FALSE; FatalEnv = &env; if( (ret = setjmp( env )) != 0 ) { /* if fatal error has occurred */ *fatal_error = TRUE; } else { argv = getFrontEndArgv( args, argc, infile, outfile ); ret = FrontEnd( argv ); } if( !GlobalCompFlags.ide_cmd_line_has_files ) { free( argv ); } #if HEAP_CHK == 1 heap_check(); #endif return( ret != 0 ); }
IDEBool IDEAPI IDERunYourSelf // COMPILE A PROGRAM ( IDEDllHdl hdl // - handle for this instantiation , const char* opts // - options , IDEBool* fatal_error ) { // - addr[fatality indication] //**************************** // Do a compile of a file //**************************** jmp_buf env; char infile[_MAX_PATH]; // - input file name char outfile[4 + _MAX_PATH]; // - output file name (need room for "-fo=") char *argv[4]; int ret; hdl = hdl; TBreak(); // clear any pending IDEStopRunning's *fatal_error = FALSE; FatalEnv = &env; if( (ret = setjmp( env )) != 0 ) { /* if fatal error has occurred */ *fatal_error = TRUE; } else { argv[0] = (char *)opts; argv[1] = NULL; getFrontEndArgv( argv, 0, infile, outfile ); ret = FrontEnd( argv ); } #if HEAP_CHK == 1 heap_check(); #endif #ifdef __OS2__ _heapmin(); #endif return( ret != 0 ); }
void dline_insert() { dline_t deadline = ask_deadline(); int p = heap_get_max_proc(&myheap); if (dl_time_before(heap_get_max_dline(&myheap), deadline)) printf("Too large!\n"); else { heap_preempt(&myheap, p, deadline); heap_print(&myheap); if (!heap_check(&myheap)) exit(-1); } }
/********************************************************************************************************* ** Function name: kheap_check ** Descriptions: 检查内核内存堆 ** input parameters: NONE ** output parameters: NONE ** Returned value: NONE *********************************************************************************************************/ void kheap_check(void) { reg_t reg; reg = interrupt_disable(); heap_check(&kern_heap, __func__, __LINE__); #if defined(DMA_MEM_BASE) && DMA_MEM_SIZE > 0 heap_check(&dma_heap, __func__, __LINE__); #endif #if defined(HW_SHARE_MEM_BASE) && HW_SHARE_MEM_SIZE > 0 heap_check(&hw_share_heap, __func__, __LINE__); #endif #if defined(SW_SHARE_MEM_BASE) && SW_SHARE_MEM_SIZE > 0 heap_check(&sw_share_heap, __func__, __LINE__); #endif interrupt_resume(reg); }
void dline_update() { printf("Select a processor (0-7): "); int proc; scanf("%d", &proc); if (proc >7 || proc <0) printf("Wrong processor!\n"); else { dline_t deadline = ask_deadline(); if (dl_time_before(deadline, myheap.nodes[proc].deadline)) printf("deadline too short\n"); else { heap_finish(&myheap, proc, deadline); heap_print(&myheap); if (!heap_check(&myheap)) exit(-1); } } }
void prop_check(int fd, xar_t x, xar_file_t f) { xar_iter_t i; const char *key, *value; const char *name = NULL; char *tmp; off_t offset = 0, length = 0; const char *origcsum = NULL; i = xar_iter_new(); if( !i ) { fprintf(stderr, "Error creating new prop iter\n"); exit(1); } xar_prop_get(f, "name", &name); for( key = xar_prop_first(f, i); key; key = xar_prop_next(i) ) { asprintf(&tmp, "%s/offset", key); if( xar_prop_get(f, tmp, &value) == 0 ) { offset = strtoll(value, NULL, 10); } free(tmp); asprintf(&tmp, "%s/length", key); if( xar_prop_get(f, tmp, &value) == 0 ) { length = strtoll(value, NULL, 10); } free(tmp); asprintf(&tmp, "%s/archived-checksum", key); if( xar_prop_get(f, tmp, &value) == 0 ) { origcsum = value; } free(tmp); if( offset && length && origcsum ) { heap_check(fd, name, key, offset, length, origcsum); offset = 0; length = 0; origcsum = NULL; } } }
/* * pmemobj_check_basic -- (internal) basic pool consistency check * * Used to check if all the replicas are consistent prior to pool recovery. */ static int pmemobj_check_basic(PMEMobjpool *pop) { LOG(3, "pop %p", pop); int consistent = 1; if (pop->run_id % 2) { ERR("invalid run_id %ju", pop->run_id); consistent = 0; } if ((errno = lane_check(pop)) != 0) { LOG(2, "!lane_check"); consistent = 0; } if ((errno = heap_check(pop)) != 0) { LOG(2, "!heap_check"); consistent = 0; } return consistent; }
/* * palloc_heap_check -- verifies heap state */ int palloc_heap_check(void *heap_start, uint64_t heap_size) { return heap_check(heap_start, heap_size); }
static void test_recycler(void) { struct mock_pop *mpop = MMAP_ANON_ALIGNED(MOCK_POOL_SIZE, Ut_mmap_align); PMEMobjpool *pop = &mpop->p; memset(pop, 0, MOCK_POOL_SIZE); pop->heap_offset = (uint64_t)((uint64_t)&mpop->heap - (uint64_t)mpop); pop->p_ops.persist = obj_heap_persist; pop->p_ops.memset_persist = obj_heap_memset_persist; pop->p_ops.base = pop; pop->set = MALLOC(sizeof(*(pop->set))); pop->set->options = 0; pop->set->directory_based = 0; void *heap_start = (char *)pop + pop->heap_offset; uint64_t heap_size = MOCK_POOL_SIZE - sizeof(PMEMobjpool); struct palloc_heap *heap = &pop->heap; struct pmem_ops *p_ops = &pop->p_ops; struct stats *s = stats_new(pop); UT_ASSERTne(s, NULL); UT_ASSERT(heap_check(heap_start, heap_size) != 0); UT_ASSERT(heap_init(heap_start, heap_size, &pop->heap_size, p_ops) == 0); UT_ASSERT(heap_boot(heap, heap_start, heap_size, &pop->heap_size, pop, p_ops, s, pop->set) == 0); UT_ASSERT(heap_buckets_init(heap) == 0); UT_ASSERT(pop->heap.rt != NULL); /* trigger heap bucket populate */ struct memory_block m = MEMORY_BLOCK_NONE; m.size_idx = 1; struct bucket *b = heap_bucket_acquire_by_id(heap, DEFAULT_ALLOC_CLASS_ID); UT_ASSERT(heap_get_bestfit_block(heap, b, &m) == 0); heap_bucket_release(heap, b); int ret; struct recycler *r = recycler_new(&pop->heap, 10000 /* never recalc */); UT_ASSERTne(r, NULL); init_run_with_score(pop->heap.layout, 0, 64); init_run_with_score(pop->heap.layout, 1, 128); init_run_with_score(pop->heap.layout, 15, 0); struct memory_block mrun = {0, 0, 1, 0}; struct memory_block mrun2 = {1, 0, 1, 0}; memblock_rebuild_state(&pop->heap, &mrun); memblock_rebuild_state(&pop->heap, &mrun2); ret = recycler_put(r, &mrun, recycler_calc_score(&pop->heap, &mrun, NULL)); UT_ASSERTeq(ret, 0); ret = recycler_put(r, &mrun2, recycler_calc_score(&pop->heap, &mrun2, NULL)); UT_ASSERTeq(ret, 0); struct memory_block mrun_ret = MEMORY_BLOCK_NONE; mrun_ret.size_idx = 1; struct memory_block mrun2_ret = MEMORY_BLOCK_NONE; mrun2_ret.size_idx = 1; ret = recycler_get(r, &mrun_ret); UT_ASSERTeq(ret, 0); ret = recycler_get(r, &mrun2_ret); UT_ASSERTeq(ret, 0); UT_ASSERTeq(mrun2.chunk_id, mrun2_ret.chunk_id); UT_ASSERTeq(mrun.chunk_id, mrun_ret.chunk_id); init_run_with_score(pop->heap.layout, 7, 256); init_run_with_score(pop->heap.layout, 2, 64); init_run_with_score(pop->heap.layout, 5, 512); init_run_with_score(pop->heap.layout, 10, 128); mrun.chunk_id = 7; mrun2.chunk_id = 2; struct memory_block mrun3 = {5, 0, 1, 0}; struct memory_block mrun4 = {10, 0, 1, 0}; memblock_rebuild_state(&pop->heap, &mrun3); memblock_rebuild_state(&pop->heap, &mrun4); mrun_ret.size_idx = 1; mrun2_ret.size_idx = 1; struct memory_block mrun3_ret = MEMORY_BLOCK_NONE; mrun3_ret.size_idx = 1; struct memory_block mrun4_ret = MEMORY_BLOCK_NONE; mrun4_ret.size_idx = 1; ret = recycler_put(r, &mrun, recycler_calc_score(&pop->heap, &mrun, NULL)); UT_ASSERTeq(ret, 0); ret = recycler_put(r, &mrun2, recycler_calc_score(&pop->heap, &mrun2, NULL)); UT_ASSERTeq(ret, 0); ret = recycler_put(r, &mrun3, recycler_calc_score(&pop->heap, &mrun3, NULL)); UT_ASSERTeq(ret, 0); ret = recycler_put(r, &mrun4, recycler_calc_score(&pop->heap, &mrun4, NULL)); UT_ASSERTeq(ret, 0); ret = recycler_get(r, &mrun2_ret); UT_ASSERTeq(ret, 0); ret = recycler_get(r, &mrun4_ret); UT_ASSERTeq(ret, 0); ret = recycler_get(r, &mrun_ret); UT_ASSERTeq(ret, 0); ret = recycler_get(r, &mrun3_ret); UT_ASSERTeq(ret, 0); UT_ASSERTeq(mrun.chunk_id, mrun_ret.chunk_id); UT_ASSERTeq(mrun2.chunk_id, mrun2_ret.chunk_id); UT_ASSERTeq(mrun3.chunk_id, mrun3_ret.chunk_id); UT_ASSERTeq(mrun4.chunk_id, mrun4_ret.chunk_id); init_run_with_max_block(pop->heap.layout, 1); struct memory_block mrun5 = {1, 0, 1, 0}; memblock_rebuild_state(&pop->heap, &mrun5); ret = recycler_put(r, &mrun5, recycler_calc_score(&pop->heap, &mrun5, NULL)); UT_ASSERTeq(ret, 0); struct memory_block mrun5_ret = MEMORY_BLOCK_NONE; mrun5_ret.size_idx = 11; ret = recycler_get(r, &mrun5_ret); UT_ASSERTeq(ret, ENOMEM); mrun5_ret = MEMORY_BLOCK_NONE; mrun5_ret.size_idx = 10; ret = recycler_get(r, &mrun5_ret); UT_ASSERTeq(ret, 0); recycler_delete(r); stats_delete(pop, s); heap_cleanup(heap); UT_ASSERT(heap->rt == NULL); FREE(pop->set); MUNMAP_ANON_ALIGNED(mpop, MOCK_POOL_SIZE); }
static void test_heap(void) { struct mock_pop *mpop = MMAP_ANON_ALIGNED(MOCK_POOL_SIZE, Ut_mmap_align); PMEMobjpool *pop = &mpop->p; memset(pop, 0, MOCK_POOL_SIZE); pop->heap_offset = (uint64_t)((uint64_t)&mpop->heap - (uint64_t)mpop); pop->p_ops.persist = obj_heap_persist; pop->p_ops.memset_persist = obj_heap_memset_persist; pop->p_ops.base = pop; pop->set = MALLOC(sizeof(*(pop->set))); pop->set->options = 0; pop->set->directory_based = 0; struct stats *s = stats_new(pop); UT_ASSERTne(s, NULL); void *heap_start = (char *)pop + pop->heap_offset; uint64_t heap_size = MOCK_POOL_SIZE - sizeof(PMEMobjpool); struct palloc_heap *heap = &pop->heap; struct pmem_ops *p_ops = &pop->p_ops; UT_ASSERT(heap_check(heap_start, heap_size) != 0); UT_ASSERT(heap_init(heap_start, heap_size, &pop->heap_size, p_ops) == 0); UT_ASSERT(heap_boot(heap, heap_start, heap_size, &pop->heap_size, pop, p_ops, s, pop->set) == 0); UT_ASSERT(heap_buckets_init(heap) == 0); UT_ASSERT(pop->heap.rt != NULL); test_alloc_class_bitmap_correctness(); test_container((struct block_container *)container_new_ravl(heap), heap); test_container((struct block_container *)container_new_seglists(heap), heap); struct alloc_class *c_small = heap_get_best_class(heap, 1); struct alloc_class *c_big = heap_get_best_class(heap, 2048); UT_ASSERT(c_small->unit_size < c_big->unit_size); /* new small buckets should be empty */ UT_ASSERT(c_big->type == CLASS_RUN); struct memory_block blocks[MAX_BLOCKS] = { {0, 0, 1, 0}, {0, 0, 1, 0}, {0, 0, 1, 0} }; struct bucket *b_def = heap_bucket_acquire_by_id(heap, DEFAULT_ALLOC_CLASS_ID); for (int i = 0; i < MAX_BLOCKS; ++i) { heap_get_bestfit_block(heap, b_def, &blocks[i]); UT_ASSERT(blocks[i].block_off == 0); } heap_bucket_release(heap, b_def); struct memory_block old_run = {0, 0, 1, 0}; struct memory_block new_run = {0, 0, 0, 0}; struct alloc_class *c_run = heap_get_best_class(heap, 1024); struct bucket *b_run = heap_bucket_acquire(heap, c_run); /* * Allocate blocks from a run until one run is exhausted. */ UT_ASSERTne(heap_get_bestfit_block(heap, b_run, &old_run), ENOMEM); int *nresv = bucket_current_resvp(b_run); do { new_run.chunk_id = 0; new_run.block_off = 0; new_run.size_idx = 1; UT_ASSERTne(heap_get_bestfit_block(heap, b_run, &new_run), ENOMEM); UT_ASSERTne(new_run.size_idx, 0); *nresv = 0; } while (old_run.block_off != new_run.block_off); *nresv = 0; heap_bucket_release(heap, b_run); stats_delete(pop, s); UT_ASSERT(heap_check(heap_start, heap_size) == 0); heap_cleanup(heap); UT_ASSERT(heap->rt == NULL); FREE(pop->set); MUNMAP_ANON_ALIGNED(mpop, MOCK_POOL_SIZE); }
static void test_heap() { struct mock_pop *mpop = Malloc(MOCK_POOL_SIZE); PMEMobjpool *pop = &mpop->p; memset(pop, 0, MOCK_POOL_SIZE); pop->size = MOCK_POOL_SIZE; pop->heap_size = MOCK_POOL_SIZE - sizeof(PMEMobjpool); pop->heap_offset = (uint64_t)((uint64_t)&mpop->heap - (uint64_t)mpop); pop->p_ops.persist = obj_heap_persist; pop->p_ops.memset_persist = obj_heap_memset_persist; pop->p_ops.base = pop; pop->p_ops.pool_size = pop->size; void *heap_start = (char *)pop + pop->heap_offset; uint64_t heap_size = pop->heap_size; struct palloc_heap *heap = &pop->heap; struct pmem_ops *p_ops = &pop->p_ops; UT_ASSERT(heap_check(heap_start, heap_size) != 0); UT_ASSERT(heap_init(heap_start, heap_size, p_ops) == 0); UT_ASSERT(heap_boot(heap, heap_start, heap_size, pop, p_ops) == 0); UT_ASSERT(pop->heap.rt != NULL); struct bucket *b_small = heap_get_best_bucket(heap, 1); struct bucket *b_big = heap_get_best_bucket(heap, 2048); UT_ASSERT(b_small->unit_size < b_big->unit_size); struct bucket *b_def = heap_get_best_bucket(heap, CHUNKSIZE); UT_ASSERT(b_def->unit_size == CHUNKSIZE); /* new small buckets should be empty */ UT_ASSERT(b_small->type == BUCKET_RUN); UT_ASSERT(b_big->type == BUCKET_RUN); struct memory_block blocks[MAX_BLOCKS] = { {0, 0, 1, 0}, {0, 0, 1, 0}, {0, 0, 1, 0} }; for (int i = 0; i < MAX_BLOCKS; ++i) { heap_get_bestfit_block(heap, b_def, &blocks[i]); UT_ASSERT(blocks[i].block_off == 0); } struct memory_block prev; heap_get_adjacent_free_block(heap, b_def, &prev, blocks[1], 1); UT_ASSERT(prev.chunk_id == blocks[0].chunk_id); struct memory_block cnt; heap_get_adjacent_free_block(heap, b_def, &cnt, blocks[0], 0); UT_ASSERT(cnt.chunk_id == blocks[1].chunk_id); struct memory_block next; heap_get_adjacent_free_block(heap, b_def, &next, blocks[1], 0); UT_ASSERT(next.chunk_id == blocks[2].chunk_id); UT_ASSERT(heap_check(heap_start, heap_size) == 0); heap_cleanup(heap); UT_ASSERT(heap->rt == NULL); Free(mpop); }
static void test_heap() { struct mock_pop *mpop = Malloc(MOCK_POOL_SIZE); PMEMobjpool *pop = &mpop->p; memset(pop, 0, MOCK_POOL_SIZE); pop->size = MOCK_POOL_SIZE; pop->heap_size = MOCK_POOL_SIZE - sizeof(PMEMobjpool); pop->heap_offset = (uint64_t)((uint64_t)&mpop->heap - (uint64_t)mpop); pop->persist = obj_heap_persist; UT_ASSERT(heap_check(pop) != 0); UT_ASSERT(heap_init(pop) == 0); UT_ASSERT(heap_boot(pop) == 0); UT_ASSERT(pop->heap != NULL); struct bucket *b_small = heap_get_best_bucket(pop, 1); struct bucket *b_big = heap_get_best_bucket(pop, 2048); UT_ASSERT(b_small->unit_size < b_big->unit_size); struct bucket *b_def = heap_get_best_bucket(pop, CHUNKSIZE); UT_ASSERT(b_def->unit_size == CHUNKSIZE); /* new small buckets should be empty */ UT_ASSERT(b_small->type == BUCKET_RUN); UT_ASSERT(b_big->type == BUCKET_RUN); struct memory_block blocks[MAX_BLOCKS] = { {0, 0, 1, 0}, {0, 0, 1, 0}, {0, 0, 1, 0} }; for (int i = 0; i < MAX_BLOCKS; ++i) { heap_get_bestfit_block(pop, b_def, &blocks[i]); UT_ASSERT(blocks[i].block_off == 0); } struct memory_block *blocksp[MAX_BLOCKS] = {NULL}; struct memory_block prev; heap_get_adjacent_free_block(pop, b_def, &prev, blocks[1], 1); UT_ASSERT(prev.chunk_id == blocks[0].chunk_id); blocksp[0] = &prev; struct memory_block cnt; heap_get_adjacent_free_block(pop, b_def, &cnt, blocks[0], 0); UT_ASSERT(cnt.chunk_id == blocks[1].chunk_id); blocksp[1] = &cnt; struct memory_block next; heap_get_adjacent_free_block(pop, b_def, &next, blocks[1], 0); UT_ASSERT(next.chunk_id == blocks[2].chunk_id); blocksp[2] = &next; struct operation_context *ctx = operation_init(pop, NULL); struct memory_block result = heap_coalesce(pop, blocksp, MAX_BLOCKS, HEAP_OP_FREE, ctx); operation_process(ctx); operation_delete(ctx); UT_ASSERT(result.size_idx == 3); UT_ASSERT(result.chunk_id == prev.chunk_id); UT_ASSERT(heap_check(pop) == 0); heap_cleanup(pop); UT_ASSERT(pop->heap == NULL); Free(mpop); }