// Add memory pool(s) for one generation
void MemoryService::add_generation_memory_pool(Generation* gen,
MemoryManager* major_mgr,
MemoryManager* minor_mgr) {
Generation::Name kind = gen->kind();
int index = _pools_list->length();
switch (kind) {
case Generation::DefNew: {
assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers");
DefNewGeneration* young_gen = (DefNewGeneration*) gen;
// Add a memory pool for each space and young gen doesn't
// support low memory detection as it is expected to get filled up.
MemoryPool* eden = add_space(young_gen->eden(),
"Eden Space",
true, /* is_heap */
young_gen->max_eden_size(),
false /* support_usage_threshold */);
MemoryPool* survivor = add_survivor_spaces(young_gen,
"Survivor Space",
true, /* is_heap */
young_gen->max_survivor_size(),
false /* support_usage_threshold */);
break;
}
case Generation::MarkSweepCompact: {
assert(major_mgr != NULL && minor_mgr == NULL, "Should have only one manager");
add_gen(gen,
"Tenured Gen",
true, /* is_heap */
true /* support_usage_threshold */);
break;
}
default:
assert(false, "should not reach here");
// no memory pool added for others
break;
}
assert(major_mgr != NULL, "Should have at least one manager");
// Link managers and the memory pools together
for (int i = index; i < _pools_list->length(); i++) {
MemoryPool* pool = _pools_list->at(i);
major_mgr->add_pool(pool);
if (minor_mgr != NULL) {
minor_mgr->add_pool(pool);
}
}
}
int mesh_worker_handler(void *data)
{
for(;;) {
task t;
if (get_pending_task(&t)) {
switch (t.task_type) {
case JOB_build_mesh: {
stbvox_mesh_maker mm;
mesh_chunk *mc = malloc(sizeof(*mc));
built_mesh out_mesh;
vec3i wc = { t.world_x, t.world_y, 0 };
stbvox_init_mesh_maker(&mm);
mc->chunk_x = t.world_x >> MESH_CHUNK_CACHE_X_LOG2;
mc->chunk_y = t.world_y >> MESH_CHUNK_CACHE_Y_LOG2;
generate_mesh_for_chunk_set(&mm, mc, wc, &t.cs, vertex_build_buffer, sizeof(vertex_build_buffer), face_buffer);
out_mesh.vertex_build_buffer = malloc(mc->num_quads * 16);
out_mesh.face_buffer = malloc(mc->num_quads * 4);
memcpy(out_mesh.vertex_build_buffer, vertex_build_buffer, mc->num_quads * 16);
memcpy(out_mesh.face_buffer, face_buffer, mc->num_quads * 4);
out_mesh.mc = mc;
if (!add_built_mesh(&out_mesh)) {
free(out_mesh.vertex_build_buffer);
free(out_mesh.face_buffer);
}
break;
}
case JOB_generate_terrain: {
finished_gen_chunk fgc;
fgc.world_x = t.world_x;
fgc.world_y = t.world_y;
fgc.gc = generate_chunk(t.world_x, t.world_y);
if (!add_gen(fgc))
free(fgc.gc);
break;
}
}
}
}
}
// Add memory pool(s) for one generation
void MemoryService::add_generation_memory_pool(Generation* gen,
MemoryManager* major_mgr,
MemoryManager* minor_mgr) {
guarantee(gen != NULL, "No generation for memory pool");
Generation::Name kind = gen->kind();
int index = _pools_list->length();
switch (kind) {
case Generation::DefNew: {
assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers");
DefNewGeneration* young_gen = (DefNewGeneration*) gen;
// Add a memory pool for each space and young gen doesn't
// support low memory detection as it is expected to get filled up.
MemoryPool* eden = add_space(young_gen->eden(),
"Eden Space",
true, /* is_heap */
young_gen->max_eden_size(),
false /* support_usage_threshold */);
MemoryPool* survivor = add_survivor_spaces(young_gen,
"Survivor Space",
true, /* is_heap */
young_gen->max_survivor_size(),
false /* support_usage_threshold */);
break;
}
#if INCLUDE_ALL_GCS
case Generation::ParNew:
case Generation::ASParNew:
{
assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers");
// Add a memory pool for each space and young gen doesn't
// support low memory detection as it is expected to get filled up.
ParNewGeneration* parnew_gen = (ParNewGeneration*) gen;
MemoryPool* eden = add_space(parnew_gen->eden(),
"Par Eden Space",
true /* is_heap */,
parnew_gen->max_eden_size(),
false /* support_usage_threshold */);
MemoryPool* survivor = add_survivor_spaces(parnew_gen,
"Par Survivor Space",
true, /* is_heap */
parnew_gen->max_survivor_size(),
false /* support_usage_threshold */);
break;
}
#endif // INCLUDE_ALL_GCS
case Generation::MarkSweepCompact: {
assert(major_mgr != NULL && minor_mgr == NULL, "Should have only one manager");
add_gen(gen,
"Tenured Gen",
true, /* is_heap */
true /* support_usage_threshold */);
break;
}
#if INCLUDE_ALL_GCS
case Generation::ConcurrentMarkSweep:
case Generation::ASConcurrentMarkSweep:
{
assert(major_mgr != NULL && minor_mgr == NULL, "Should have only one manager");
ConcurrentMarkSweepGeneration* cms = (ConcurrentMarkSweepGeneration*) gen;
MemoryPool* pool = add_cms_space(cms->cmsSpace(),
"CMS Old Gen",
true, /* is_heap */
cms->reserved().byte_size(),
true /* support_usage_threshold */);
break;
}
#endif // INCLUDE_ALL_GCS
default:
assert(false, "should not reach here");
// no memory pool added for others
break;
}
assert(major_mgr != NULL, "Should have at least one manager");
// Link managers and the memory pools together
for (int i = index; i < _pools_list->length(); i++) {
MemoryPool* pool = _pools_list->at(i);
major_mgr->add_pool(pool);
if (minor_mgr != NULL) {
minor_mgr->add_pool(pool);
}
}
}
