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