C++ cdie函数代码示例

static void test(void)
{
 mps_space_t space;
 mps_thr_t thread;
 mps_addr_t a[32];
 mps_root_t root;

 cdie(mps_space_create(&space), "create space");

 cdie(mps_thread_reg(&thread, space), "register thread");

 cdie(mps_root_create_fmt(&root, space, MPS_RANK_AMBIG, 0, 
                      fmtscan, a, (mps_addr_t)(((char *)(&a[0]))+1)),
      "root create");

}

static void test(void)
{
 mps_arena_t arena;
 mps_thr_t thread;
 mps_addr_t a[32];
 mps_root_t root;

 cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena");

 cdie(mps_thread_reg(&thread, arena), "register thread");

 cdie(mps_root_create_fmt(&root, arena, mps_rank_ambig(), 0, 
                      fmtscan, &a[10], &a[0]),
      "root create");

}

static void test(void)
{
 mps_arena_t arena;
 mps_thr_t thread;
 mps_root_t root;
 mps_addr_t a[30];

 cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena");

 cdie(mps_thread_reg(&thread, arena), "register thread");

 cdie(mps_root_create_table(&root, arena,
        mps_rank_ambig(), 0, a, (size_t) 0),
      "root create");

}

static void test(void)
{
 mps_space_t space;
 mps_thr_t thread;
 mps_root_t root;
 mps_addr_t a[30];

 cdie(mps_space_create(&space), "create space");

 cdie(mps_thread_reg(&thread, space), "register thread");

 cdie(mps_root_create_table(&root, space,
        MPS_RANK_AMBIG, 0, a, (size_t) -32),
      "root create");

}

static void test(void)
{
 mps_arena_t arena;
 mps_pool_t pool;

 cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena");

 cdie(
  mps_pool_create(
     &pool, arena, mps_class_mv(),
     (size_t) 32, (size_t) 0, (size_t) 32),
  "create pool");

 mps_pool_destroy(pool);
 mps_arena_destroy(arena);
}

static void test(void)
{
 mps_arena_t arena;
 mps_pool_t pool;
 size_t extendBy;
 size_t avgSize;
 size_t maxSize;

 extendBy = (size_t) 4096;
 avgSize  = (size_t) 32;
 maxSize  = (size_t) 65536;

 cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena");

/*
 cdie(
  mps_pool_create(&pool, arena, mps_class_mv(),
   extendBy, avgSize, maxSize),
  "create pool");
*/

 mps_pool_destroy(pool);
 comment("Destroyed pool.");

 mps_arena_destroy(arena);
 comment("Destroyed arena.");
}

static void test(void *stack_pointer)
{
 mps_arena_t arena;
 mps_thr_t thread;
 mps_root_t root;

 cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena");

 cdie(mps_thread_reg(&thread, arena), "register thread");

 cdie(mps_root_create_reg(&root, arena, mps_rank_ambig(),
                      HIGHBIT_INT, 
                      thread, mps_stack_scan_ambig, stack_pointer, 0),
      "root create");

}

static void test(void)
{
 mps_space_t space;

 cdie(mps_space_create(&space), "create space");
 mps_space_destroy(space);
}

static void test(void *stack_pointer)
{
 mps_pool_t pool = malloc(4096);
 mps_addr_t obj;

 cdie(mps_alloc(&obj, pool, 152), "allocate");
}

static void test(void)
{
 mps_space_t space;
 mps_thr_t thread;
 mps_addr_t a[32];
 mps_root_t root;

 cdie(mps_space_create(&space), "create space");

 cdie(mps_thread_reg(&thread, space), "register thread");

 cdie(mps_root_create_fmt(&root, space, MPS_RANK_AMBIG, HIGHBIT_INT, 
                      fmtscan, a, &a[32]),
      "root create");

}

static void test(void)
{
 mps_arena_t arena;
 mps_fmt_t format;
 mps_fmt_A_s fmtA;

 arena=malloc(64);

 /* cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena");
 */ 
 fmtA.align = (mps_align_t) 1;
 fmtA.scan  = &zilch;
 fmtA.skip  = &myskip;
 fmtA.copy  = &zilch;
 fmtA.fwd   = &zilch;
 fmtA.isfwd = &zilch;
 fmtA.pad   = &zilch;

 cdie(
  mps_fmt_create_A(&format, arena, &fmtA), 
  "create format");

 mps_arena_destroy(arena);
 comment("Destroy arena.");
}

static void test(void)
{
 mps_space_t space;
 mps_pool_t pool;
 size_t extendBy;
 size_t avgSize;
 size_t maxSize;

 extendBy = (size_t) 4096;
 avgSize  = (size_t) 32;
 maxSize  = (size_t) 65536;

/* cdie(mps_space_create(&space), "create space");
*/
 space=malloc(64);

 cdie(
  mps_pool_create(&pool, space, mps_class_mv(),
   extendBy, avgSize, maxSize),
  "create pool");

 mps_pool_destroy(pool);
 comment("Destroyed pool.");

 mps_space_destroy(space);
 comment("Destroyed space.");
}

static void test(void *stack_pointer)
{
 mps_arena_t arena;
 mps_pool_t pool;
 mps_thr_t thread;
 mps_root_t root;

 mps_chain_t chain;
 mps_fmt_t format;
 mps_ap_t ap;

 cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena");

 cdie(mps_thread_reg(&thread, arena), "register thread");

 cdie(mps_root_create_thread(&root, arena, thread, stack_pointer), "thread root");
 cdie(
  mps_fmt_create_A(&format, arena, &fmtA),
  "create format");

 cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");

 cdie(
  mps_pool_create(&pool, arena, mps_class_amc(), format, chain),
  "create pool");

 cdie(
  mps_ap_create(&ap, pool, mps_rank_exact()),
  "create ap");

{
 mps_addr_t p;

 cdie(mps_reserve(&p, ap, 0x100), "Reserve: ");
}

 mps_ap_destroy(ap);
 comment("Destroyed ap.");

 mps_pool_destroy(pool);
 comment("Destroyed pool.");

 mps_fmt_destroy(format);
 comment("Destroyed format.");

 mps_chain_destroy(chain);
 comment("Destroyed chain.");

 mps_root_destroy(root);
 comment("Destroyed root.");

 mps_thread_dereg(thread);
 comment("Deregistered thread.");

 mps_arena_destroy(arena);
 comment("Destroyed arena.");
}

static void report(mps_arena_t arena)
{
  static int nCollections = 0;
  mps_message_type_t type;
    
  while(mps_message_queue_type(&type, arena)) {
    mps_message_t message;

    cdie(mps_message_get(&message, arena, type), "message get");

    switch(type) {
    /* @@@@ is using these macros in a switch supported? */
    case mps_message_type_gc():
      {
	size_t live, condemned, not_condemned;

	live = mps_message_gc_live_size(arena, message);
	condemned = mps_message_gc_condemned_size(arena, message);
	not_condemned = mps_message_gc_not_condemned_size(arena, message);

	printf("\nCollection %d finished:\n", ++nCollections);
	printf("live %lu\n", (unsigned long)live);
	printf("condemned %lu\n", (unsigned long)condemned);
	printf("not_condemned %lu\n", (unsigned long)not_condemned);

	if(condemned > (gen1SIZE + gen2SIZE + (size_t)128) * 1024) {
	  /* When condemned size is larger than could happen in a gen 2
	   * collection (discounting ramps, natch), guess that was a dynamic
	   * collection, and reset the commit limit, so it doesn't run out. */
	  die(mps_arena_commit_limit_set(arena, 2 * testArenaSIZE),
	    "set limit");
	}
      }
      break;
    case mps_message_type_gc_start():
      printf("\nCollection started.  Because:\n");
      printf("%s\n", mps_message_gc_start_why(arena, message));

      break;
    default:
      cdie(0, "unknown message type");
    }
    mps_message_discard(arena, message);
  }

  return;
}

static void test(void)
{
 mps_space_t space;
 mps_space_t space1;
 mps_ld_s ld;

 cdie(mps_space_create(&space), "create space");
 cdie(mps_space_create(&space1), "create space 1");

 mps_ld_reset(&ld, space);
 comment("Reset ld."); 

 report("isstale", "%d", mps_ld_isstale(&ld, space1, &space));

 mps_space_destroy(space);
 comment("Destroyed space.");
}