// simulate NTM until it halts or nr_steps steps are reached
void NTM::simulate(uint max_nr_steps, bool verbose)
{
uint c_symbol;
uint c_state;
while(nr_steps <= max_nr_steps) {
list<TM_State> new_tm_states;
if ( verbose ) {
cout << "Nr steps: " << nr_steps << endl;
cout << "There are " << tm_states.size() << " states" << endl;
}
for (list<TM_State>::const_iterator it = tm_states.begin();
it != tm_states.end(); ++it) {
c_symbol = it->tape.read();
c_state = it->state;
if ( !is_final_state(c_state) ) {
for(list<Action>::const_iterator act_it =
trans_actions[c_state][c_symbol].begin();
act_it != trans_actions[c_state][c_symbol].end();
++act_it) {
TM_State tms(*it);
tms.state = act_it->state;
tms.tape.write(act_it->symbol);
tms.tape.move(act_it->move);
new_tm_states.push_front(tms);
// if(verbose) {
// print(tms);
// }
}
}
}
nr_steps++;
swap(tm_states, new_tm_states);
}
cout << "Done simulating!" << endl;
}
void
ModelObject::cut(coordf_t z, Model* model) const
{
// clone this one to duplicate instances, materials etc.
ModelObject* upper = model->add_object(*this);
ModelObject* lower = model->add_object(*this);
upper->clear_volumes();
lower->clear_volumes();
for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) {
ModelVolume* volume = *v;
if (volume->modifier) {
// don't cut modifiers
upper->add_volume(*volume);
lower->add_volume(*volume);
} else {
TriangleMeshSlicer tms(&volume->mesh);
TriangleMesh upper_mesh, lower_mesh;
// TODO: shouldn't we use object bounding box instead of per-volume bb?
tms.cut(z + volume->mesh.bounding_box().min.z, &upper_mesh, &lower_mesh);
upper_mesh.repair();
lower_mesh.repair();
upper_mesh.reset_repair_stats();
lower_mesh.reset_repair_stats();
if (upper_mesh.facets_count() > 0) {
ModelVolume* vol = upper->add_volume(upper_mesh);
vol->name = volume->name;
vol->config = volume->config;
vol->set_material(volume->material_id(), *volume->material());
}
if (lower_mesh.facets_count() > 0) {
ModelVolume* vol = lower->add_volume(lower_mesh);
vol->name = volume->name;
vol->config = volume->config;
vol->set_material(volume->material_id(), *volume->material());
}
}
}
}
// This method contains no policy. You should probably
// be calling invoke() instead.
bool PSScavenge::invoke_no_policy() {
assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread");
elapsedTimer scavenge_time;
TimeStamp scavenge_entry;
TimeStamp scavenge_midpoint;
TimeStamp scavenge_exit;
scavenge_entry.update();
if (GC_locker::check_active_before_gc()) {
return false;
}
ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
GCCause::Cause gc_cause = heap->gc_cause();
assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");
// Check for potential problems.
if (!should_attempt_scavenge()) {
return false;
}
bool promotion_failure_occurred = false;
PSYoungGen* young_gen = heap->young_gen();
PSOldGen* old_gen = heap->old_gen();
PSPermGen* perm_gen = heap->perm_gen();
PSAdaptiveSizePolicy* size_policy = heap->size_policy();
heap->increment_total_collections();
AdaptiveSizePolicyOutput(size_policy, heap->total_collections());
if ((gc_cause != GCCause::_java_lang_system_gc) ||
UseAdaptiveSizePolicyWithSystemGC) {
// Gather the feedback data for eden occupancy.
young_gen->eden_space()->accumulate_statistics();
}
// We need to track unique scavenge invocations as well.
_total_invocations++;
if (PrintHeapAtGC) {
Universe::print_heap_before_gc();
}
assert(!NeverTenure||_tenuring_threshold==markWord::max_age+1,"Sanity");
assert(!AlwaysTenure || _tenuring_threshold == 0, "Sanity");
size_t prev_used = heap->used();
assert(promotion_failed() == false, "Sanity");
// Fill in TLABs
heap->accumulate_statistics_all_tlabs();
heap->ensure_parsability(true); // retire TLABs
if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
gclog_or_tty->print(" VerifyBeforeGC:");
Universe::verify(true);
}
{
ResourceMark rm;
HandleMark hm;
gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps);
TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
TraceTime t1("GC", PrintGC, !PrintGCDetails, gclog_or_tty);
TraceCollectorStats tcs(counters());
TraceMemoryManagerStats tms(false /* not full GC */);
if (TraceGen0Time) scavenge_time.start();
// Let the size policy know we're starting
size_policy->minor_collection_begin();
// Verify the object start arrays.
if (VerifyObjectStartArray &&
VerifyBeforeGC) {
old_gen->verify_object_start_array();
perm_gen->verify_object_start_array();
}
// Verify no unmarked old->young roots
if (VerifyRememberedSets) {
CardTableExtension::verify_all_young_refs_imprecise();
}
if (!ScavengeWithObjectsInToSpace) {
assert(young_gen->to_space()->is_empty(),
"Attempt to scavenge with live objects in to_space");
young_gen->to_space()->clear();
} else if (ZapUnusedHeapArea) {
young_gen->to_space()->mangle_unused_area();
}
save_to_space_top_before_gc();
NOT_PRODUCT(reference_processor()->verify_no_references_recorded());
DerivedPointerTable::clear();
reference_processor()->enable_discovery();
// We track how much was promoted to the next generation for
// the AdaptiveSizePolicy.
size_t old_gen_used_before = old_gen->used_in_bytes();
// For PrintGCDetails
size_t young_gen_used_before = young_gen->used_in_bytes();
// Reset our survivor overflow.
set_survivor_overflow(false);
// We need to save the old/perm top values before
// creating the promotion_manager. We pass the top
// values to the card_table, to prevent it from
// straying into the promotion labs.
HeapWord* old_top = old_gen->object_space()->top();
HeapWord* perm_top = perm_gen->object_space()->top();
// Release all previously held resources
gc_task_manager()->release_all_resources();
PSPromotionManager::pre_scavenge();
// We'll use the promotion manager again later.
PSPromotionManager* promotion_manager = PSPromotionManager::vm_thread_promotion_manager();
{
// TraceTime("Roots");
GCTaskQueue* q = GCTaskQueue::create();
for(uint i=0; i<ParallelGCThreads; i++) {
q->enqueue(new OldToYoungRootsTask(old_gen, old_top, i));
q->enqueue(new OldToYoungRootsTask(perm_gen,perm_top,i));
}
// q->enqueue(new SerialOldToYoungRootsTask(perm_gen, perm_top));
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::universe));
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::jni_handles));
// We scan the thread roots in parallel
// FIX ME! We should have a NoResourceMarkVerifier here!
Threads::create_thread_roots_tasks(q);
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::object_synchronizer));
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::management));
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::system_dictionary));
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::jvmti));
// NOTE! ArtaObjects are not normal roots. During scavenges, they are
// considered strong roots. During a mark sweep they are weak roots.
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::arta_objects));
ParallelTaskTerminator terminator(
gc_task_manager()->workers(),
promotion_manager->depth_first() ?
(TaskQueueSetSuper*)promotion_manager->stack_array_depth()
: (TaskQueueSetSuper*)promotion_manager->stack_array_breadth());
if (ParallelGCThreads>1) {
for (uint j=0; j<ParallelGCThreads; j++) {
q->enqueue(new StealTask(&terminator));
}
}
gc_task_manager()->execute_and_wait(q);
}
scavenge_midpoint.update();
// Process reference objects discovered during scavenge
{
ReferencePolicy *soft_ref_policy = new LRUMaxHeapPolicy();
PSKeepAliveClosure keep_alive(promotion_manager);
PSEvacuateFollowersClosure evac_followers(promotion_manager);
assert(soft_ref_policy != NULL,"No soft reference policy");
if (reference_processor()->processing_is_mt()) {
PSRefProcTaskExecutor task_executor;
reference_processor()->process_discovered_references(
soft_ref_policy, &_is_alive_closure, &keep_alive, &evac_followers,
&task_executor);
} else {
reference_processor()->process_discovered_references(
soft_ref_policy, &_is_alive_closure, &keep_alive, &evac_followers,
NULL);
}
}
// Enqueue reference objects discovered during scavenge.
if (reference_processor()->processing_is_mt()) {
PSRefProcTaskExecutor task_executor;
reference_processor()->enqueue_discovered_references(&task_executor);
} else {
reference_processor()->enqueue_discovered_references(NULL);
}
// Finally, flush the promotion_manager's labs, and deallocate its stacks.
assert(promotion_manager->claimed_stack_empty(), "Sanity");
PSPromotionManager::post_scavenge();
promotion_failure_occurred = promotion_failed();
if (promotion_failure_occurred) {
_total_promotion_failures++;
clean_up_failed_promotion();
if (PrintGC) {
gclog_or_tty->print("--");
}
}
// Let the size policy know we're done. Note that we count promotion
// failure cleanup time as part of the collection (otherwise, we're
// implicitly saying it's mutator time).
size_policy->minor_collection_end(gc_cause);
if (!promotion_failure_occurred) {
// Swap the survivor spaces.
young_gen->eden_space()->clear();
young_gen->from_space()->clear();
young_gen->swap_spaces();
size_t survived = young_gen->from_space()->used_in_bytes();
size_t promoted = old_gen->used_in_bytes() - old_gen_used_before;
size_policy->update_averages(_survivor_overflow, survived, promoted);
if (UseAdaptiveSizePolicy) {
// Calculate the new survivor size and tenuring threshold
if (PrintAdaptiveSizePolicy) {
gclog_or_tty->print("AdaptiveSizeStart: ");
gclog_or_tty->stamp();
gclog_or_tty->print_cr(" collection: %d ",
heap->total_collections());
if (Verbose) {
gclog_or_tty->print("old_gen_capacity: %zd young_gen_capacity: %zd"
" perm_gen_capacity: %zd ",
old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes(),
perm_gen->capacity_in_bytes());
}
}
if (UsePerfData) {
PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters();
counters->update_old_eden_size(
size_policy->calculated_eden_size_in_bytes());
counters->update_old_promo_size(
size_policy->calculated_promo_size_in_bytes());
counters->update_old_capacity(old_gen->capacity_in_bytes());
counters->update_young_capacity(young_gen->capacity_in_bytes());
counters->update_survived(survived);
counters->update_promoted(promoted);
counters->update_survivor_overflowed(_survivor_overflow);
}
size_t survivor_limit =
size_policy->max_survivor_size(young_gen->max_size());
_tenuring_threshold =
size_policy->compute_survivor_space_size_and_threshold(
_survivor_overflow,
_tenuring_threshold,
survivor_limit);
if (PrintTenuringDistribution) {
gclog_or_tty->cr();
gclog_or_tty->print_cr("Desired survivor size %ld bytes, new threshold %d (max %ld)",
size_policy->calculated_survivor_size_in_bytes(),
_tenuring_threshold, MaxTenuringThreshold);
}
if (UsePerfData) {
PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters();
counters->update_tenuring_threshold(_tenuring_threshold);
counters->update_survivor_size_counters();
}
// Do call at minor collections?
// Don't check if the size_policy is ready at this
// level. Let the size_policy check that internally.
if (UseAdaptiveSizePolicy &&
UseAdaptiveGenerationSizePolicyAtMinorCollection &&
((gc_cause != GCCause::_java_lang_system_gc) ||
UseAdaptiveSizePolicyWithSystemGC)) {
// Calculate optimial free space amounts
assert(young_gen->max_size() >
young_gen->from_space()->capacity_in_bytes() +
young_gen->to_space()->capacity_in_bytes(),
"Sizes of space in young gen are out-of-bounds");
size_t max_eden_size = young_gen->max_size() -
young_gen->from_space()->capacity_in_bytes() -
young_gen->to_space()->capacity_in_bytes();
size_policy->compute_generation_free_space(young_gen->used_in_bytes(),
young_gen->eden_space()->used_in_bytes(),
old_gen->used_in_bytes(),
perm_gen->used_in_bytes(),
young_gen->eden_space()->capacity_in_bytes(),
old_gen->max_gen_size(),
max_eden_size,
false /* full gc*/,
gc_cause);
}
// Resize the young generation at every collection
// even if new sizes have not been calculated. This is
// to allow resizes that may have been inhibited by the
// relative location of the "to" and "from" spaces.
// Resizing the old gen at minor collects can cause increases
// that don't feed back to the generation sizing policy until
// a major collection. Don't resize the old gen here.
heap->resize_young_gen(size_policy->calculated_eden_size_in_bytes(),
size_policy->calculated_survivor_size_in_bytes());
if (PrintAdaptiveSizePolicy) {
gclog_or_tty->print_cr("AdaptiveSizeStop: collection: %d ",
heap->total_collections());
}
}
// Update the structure of the eden. With NUMA-eden CPU hotplugging or offlining can
// cause the change of the heap layout. Make sure eden is reshaped if that's the case.
// Also update() will case adaptive NUMA chunk resizing.
assert(young_gen->eden_space()->is_empty(), "eden space should be empty now");
young_gen->eden_space()->update();
heap->gc_policy_counters()->update_counters();
heap->resize_all_tlabs();
assert(young_gen->to_space()->is_empty(), "to space should be empty now");
}
DerivedPointerTable::update_pointers();
NOT_PRODUCT(reference_processor()->verify_no_references_recorded());
// Re-verify object start arrays
if (VerifyObjectStartArray &&
VerifyAfterGC) {
old_gen->verify_object_start_array();
perm_gen->verify_object_start_array();
}
// Verify all old -> young cards are now precise
if (VerifyRememberedSets) {
// Precise verification will give false positives. Until this is fixed,
// use imprecise verification.
// CardTableExtension::verify_all_young_refs_precise();
CardTableExtension::verify_all_young_refs_imprecise();
}
if (TraceGen0Time) {
scavenge_time.stop();
if (promotion_failure_occurred)
accumulated_undo_time()->add(scavenge_time);
else
accumulated_gc_time()->add(scavenge_time);
}
if (PrintGC) {
if (PrintGCDetails) {
// Don't print a GC timestamp here. This is after the GC so
// would be confusing.
young_gen->print_used_change(young_gen_used_before);
}
heap->print_heap_change(prev_used);
}
// Track memory usage and detect low memory
MemoryService::track_memory_usage();
heap->update_counters();
}
if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
gclog_or_tty->print(" VerifyAfterGC:");
Universe::verify(false);
}
if (PrintHeapAtGC) {
Universe::print_heap_after_gc();
}
scavenge_exit.update();
if (PrintGCTaskTimeStamps) {
tty->print_cr("VM-Thread %lld %lld %lld",
scavenge_entry.ticks(), scavenge_midpoint.ticks(),
scavenge_exit.ticks());
gc_task_manager()->print_task_time_stamps();
}
return !promotion_failure_occurred;
}
// This method contains no policy. You should probably
// be calling invoke() instead.
void PSMarkSweep::invoke_no_policy(bool clear_all_softrefs) {
assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint");
assert(ref_processor() != NULL, "Sanity");
if (GC_locker::check_active_before_gc()) {
return;
}
ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
GCCause::Cause gc_cause = heap->gc_cause();
assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");
PSAdaptiveSizePolicy* size_policy = heap->size_policy();
PSYoungGen* young_gen = heap->young_gen();
PSOldGen* old_gen = heap->old_gen();
PSPermGen* perm_gen = heap->perm_gen();
// Increment the invocation count
heap->increment_total_collections(true /* full */);
// Save information needed to minimize mangling
heap->record_gen_tops_before_GC();
// We need to track unique mark sweep invocations as well.
_total_invocations++;
AdaptiveSizePolicyOutput(size_policy, heap->total_collections());
if (PrintHeapAtGC) {
Universe::print_heap_before_gc();
}
// Fill in TLABs
heap->accumulate_statistics_all_tlabs();
heap->ensure_parsability(true); // retire TLABs
if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
gclog_or_tty->print(" VerifyBeforeGC:");
Universe::verify(true);
}
// Verify object start arrays
if (VerifyObjectStartArray &&
VerifyBeforeGC) {
old_gen->verify_object_start_array();
perm_gen->verify_object_start_array();
}
heap->pre_full_gc_dump();
// Filled in below to track the state of the young gen after the collection.
bool eden_empty;
bool survivors_empty;
bool young_gen_empty;
{
HandleMark hm;
const bool is_system_gc = gc_cause == GCCause::_java_lang_system_gc;
// This is useful for debugging but don't change the output the
// the customer sees.
const char* gc_cause_str = "Full GC";
if (is_system_gc && PrintGCDetails) {
gc_cause_str = "Full GC (System)";
}
gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps);
TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
TraceTime t1(gc_cause_str, PrintGC, !PrintGCDetails, gclog_or_tty);
TraceCollectorStats tcs(counters());
TraceMemoryManagerStats tms(true /* Full GC */);
if (TraceGen1Time) accumulated_time()->start();
// Let the size policy know we're starting
size_policy->major_collection_begin();
// When collecting the permanent generation methodOops may be moving,
// so we either have to flush all bcp data or convert it into bci.
CodeCache::gc_prologue();
Threads::gc_prologue();
BiasedLocking::preserve_marks();
// Capture heap size before collection for printing.
size_t prev_used = heap->used();
// Capture perm gen size before collection for sizing.
size_t perm_gen_prev_used = perm_gen->used_in_bytes();
// For PrintGCDetails
size_t old_gen_prev_used = old_gen->used_in_bytes();
size_t young_gen_prev_used = young_gen->used_in_bytes();
allocate_stacks();
NOT_PRODUCT(ref_processor()->verify_no_references_recorded());
COMPILER2_PRESENT(DerivedPointerTable::clear());
ref_processor()->enable_discovery();
ref_processor()->setup_policy(clear_all_softrefs);
mark_sweep_phase1(clear_all_softrefs);
mark_sweep_phase2();
// Don't add any more derived pointers during phase3
COMPILER2_PRESENT(assert(DerivedPointerTable::is_active(), "Sanity"));
COMPILER2_PRESENT(DerivedPointerTable::set_active(false));
mark_sweep_phase3();
mark_sweep_phase4();
restore_marks();
deallocate_stacks();
if (ZapUnusedHeapArea) {
// Do a complete mangle (top to end) because the usage for
// scratch does not maintain a top pointer.
young_gen->to_space()->mangle_unused_area_complete();
}
eden_empty = young_gen->eden_space()->is_empty();
if (!eden_empty) {
eden_empty = absorb_live_data_from_eden(size_policy, young_gen, old_gen);
}
// Update heap occupancy information which is used as
// input to soft ref clearing policy at the next gc.
Universe::update_heap_info_at_gc();
survivors_empty = young_gen->from_space()->is_empty() &&
young_gen->to_space()->is_empty();
young_gen_empty = eden_empty && survivors_empty;
BarrierSet* bs = heap->barrier_set();
if (bs->is_a(BarrierSet::ModRef)) {
ModRefBarrierSet* modBS = (ModRefBarrierSet*)bs;
MemRegion old_mr = heap->old_gen()->reserved();
MemRegion perm_mr = heap->perm_gen()->reserved();
assert(perm_mr.end() <= old_mr.start(), "Generations out of order");
if (young_gen_empty) {
modBS->clear(MemRegion(perm_mr.start(), old_mr.end()));
} else {
modBS->invalidate(MemRegion(perm_mr.start(), old_mr.end()));
}
}
BiasedLocking::restore_marks();
Threads::gc_epilogue();
CodeCache::gc_epilogue();
COMPILER2_PRESENT(DerivedPointerTable::update_pointers());
ref_processor()->enqueue_discovered_references(NULL);
// Update time of last GC
reset_millis_since_last_gc();
// Let the size policy know we're done
size_policy->major_collection_end(old_gen->used_in_bytes(), gc_cause);
if (UseAdaptiveSizePolicy) {
if (PrintAdaptiveSizePolicy) {
gclog_or_tty->print("AdaptiveSizeStart: ");
gclog_or_tty->stamp();
gclog_or_tty->print_cr(" collection: %d ",
heap->total_collections());
if (Verbose) {
gclog_or_tty->print("old_gen_capacity: %d young_gen_capacity: %d"
" perm_gen_capacity: %d ",
old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes(),
perm_gen->capacity_in_bytes());
}
}
// Don't check if the size_policy is ready here. Let
// the size_policy check that internally.
if (UseAdaptiveGenerationSizePolicyAtMajorCollection &&
((gc_cause != GCCause::_java_lang_system_gc) ||
UseAdaptiveSizePolicyWithSystemGC)) {
// Calculate optimal free space amounts
assert(young_gen->max_size() >
young_gen->from_space()->capacity_in_bytes() +
young_gen->to_space()->capacity_in_bytes(),
"Sizes of space in young gen are out-of-bounds");
size_t max_eden_size = young_gen->max_size() -
young_gen->from_space()->capacity_in_bytes() -
young_gen->to_space()->capacity_in_bytes();
size_policy->compute_generation_free_space(young_gen->used_in_bytes(),
young_gen->eden_space()->used_in_bytes(),
old_gen->used_in_bytes(),
perm_gen->used_in_bytes(),
young_gen->eden_space()->capacity_in_bytes(),
old_gen->max_gen_size(),
max_eden_size,
true /* full gc*/,
gc_cause);
heap->resize_old_gen(size_policy->calculated_old_free_size_in_bytes());
// Don't resize the young generation at an major collection. A
// desired young generation size may have been calculated but
// resizing the young generation complicates the code because the
// resizing of the old generation may have moved the boundary
// between the young generation and the old generation. Let the
// young generation resizing happen at the minor collections.
}
if (PrintAdaptiveSizePolicy) {
gclog_or_tty->print_cr("AdaptiveSizeStop: collection: %d ",
heap->total_collections());
}
}
if (UsePerfData) {
heap->gc_policy_counters()->update_counters();
heap->gc_policy_counters()->update_old_capacity(
old_gen->capacity_in_bytes());
heap->gc_policy_counters()->update_young_capacity(
young_gen->capacity_in_bytes());
}
heap->resize_all_tlabs();
// We collected the perm gen, so we'll resize it here.
perm_gen->compute_new_size(perm_gen_prev_used);
if (TraceGen1Time) accumulated_time()->stop();
if (PrintGC) {
if (PrintGCDetails) {
// Don't print a GC timestamp here. This is after the GC so
// would be confusing.
young_gen->print_used_change(young_gen_prev_used);
old_gen->print_used_change(old_gen_prev_used);
}
heap->print_heap_change(prev_used);
// Do perm gen after heap becase prev_used does
// not include the perm gen (done this way in the other
// collectors).
if (PrintGCDetails) {
perm_gen->print_used_change(perm_gen_prev_used);
}
}
// Track memory usage and detect low memory
MemoryService::track_memory_usage();
heap->update_counters();
if (PrintGCDetails) {
if (size_policy->print_gc_time_limit_would_be_exceeded()) {
if (size_policy->gc_time_limit_exceeded()) {
gclog_or_tty->print_cr(" GC time is exceeding GCTimeLimit "
"of %d%%", GCTimeLimit);
} else {
gclog_or_tty->print_cr(" GC time would exceed GCTimeLimit "
"of %d%%", GCTimeLimit);
}
}
size_policy->set_print_gc_time_limit_would_be_exceeded(false);
}
}
if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
gclog_or_tty->print(" VerifyAfterGC:");
Universe::verify(false);
}
// Re-verify object start arrays
if (VerifyObjectStartArray &&
VerifyAfterGC) {
old_gen->verify_object_start_array();
perm_gen->verify_object_start_array();
}
if (ZapUnusedHeapArea) {
old_gen->object_space()->check_mangled_unused_area_complete();
perm_gen->object_space()->check_mangled_unused_area_complete();
}
NOT_PRODUCT(ref_processor()->verify_no_references_recorded());
if (PrintHeapAtGC) {
Universe::print_heap_after_gc();
}
heap->post_full_gc_dump();
#ifdef TRACESPINNING
ParallelTaskTerminator::print_termination_counts();
#endif
}
// This method contains no policy. You should probably
// be calling invoke() instead.
bool PSMarkSweep::invoke_no_policy(bool clear_all_softrefs) {
assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint");
assert(ref_processor() != NULL, "Sanity");
if (GC_locker::check_active_before_gc()) {
return false;
}
ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
GCCause::Cause gc_cause = heap->gc_cause();
_gc_timer->register_gc_start();
_gc_tracer->report_gc_start(gc_cause, _gc_timer->gc_start());
PSAdaptiveSizePolicy* size_policy = heap->size_policy();
// The scope of casr should end after code that can change
// CollectorPolicy::_should_clear_all_soft_refs.
ClearedAllSoftRefs casr(clear_all_softrefs, heap->collector_policy());
PSYoungGen* young_gen = heap->young_gen();
PSOldGen* old_gen = heap->old_gen();
// Increment the invocation count
heap->increment_total_collections(true /* full */);
// Save information needed to minimize mangling
heap->record_gen_tops_before_GC();
// We need to track unique mark sweep invocations as well.
_total_invocations++;
AdaptiveSizePolicyOutput(size_policy, heap->total_collections());
heap->print_heap_before_gc();
heap->trace_heap_before_gc(_gc_tracer);
// Fill in TLABs
heap->accumulate_statistics_all_tlabs();
heap->ensure_parsability(true); // retire TLABs
if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
Universe::verify(" VerifyBeforeGC:");
}
// Verify object start arrays
if (VerifyObjectStartArray &&
VerifyBeforeGC) {
old_gen->verify_object_start_array();
}
heap->pre_full_gc_dump(_gc_timer);
// Filled in below to track the state of the young gen after the collection.
bool eden_empty;
bool survivors_empty;
bool young_gen_empty;
{
HandleMark hm;
TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
GCTraceTime t1(GCCauseString("Full GC", gc_cause), PrintGC, !PrintGCDetails, NULL, _gc_tracer->gc_id());
TraceCollectorStats tcs(counters());
TraceMemoryManagerStats tms(true /* Full GC */,gc_cause);
if (TraceOldGenTime) accumulated_time()->start();
// Let the size policy know we're starting
size_policy->major_collection_begin();
CodeCache::gc_prologue();
BiasedLocking::preserve_marks();
// Capture heap size before collection for printing.
size_t prev_used = heap->used();
// Capture metadata size before collection for sizing.
size_t metadata_prev_used = MetaspaceAux::used_bytes();
// For PrintGCDetails
size_t old_gen_prev_used = old_gen->used_in_bytes();
size_t young_gen_prev_used = young_gen->used_in_bytes();
allocate_stacks();
COMPILER2_PRESENT(DerivedPointerTable::clear());
ref_processor()->enable_discovery();
ref_processor()->setup_policy(clear_all_softrefs);
mark_sweep_phase1(clear_all_softrefs);
mark_sweep_phase2();
// Don't add any more derived pointers during phase3
COMPILER2_PRESENT(assert(DerivedPointerTable::is_active(), "Sanity"));
COMPILER2_PRESENT(DerivedPointerTable::set_active(false));
mark_sweep_phase3();
mark_sweep_phase4();
restore_marks();
deallocate_stacks();
if (ZapUnusedHeapArea) {
// Do a complete mangle (top to end) because the usage for
// scratch does not maintain a top pointer.
young_gen->to_space()->mangle_unused_area_complete();
}
eden_empty = young_gen->eden_space()->is_empty();
if (!eden_empty) {
eden_empty = absorb_live_data_from_eden(size_policy, young_gen, old_gen);
}
// Update heap occupancy information which is used as
// input to soft ref clearing policy at the next gc.
Universe::update_heap_info_at_gc();
survivors_empty = young_gen->from_space()->is_empty() &&
young_gen->to_space()->is_empty();
young_gen_empty = eden_empty && survivors_empty;
ModRefBarrierSet* modBS = barrier_set_cast<ModRefBarrierSet>(heap->barrier_set());
MemRegion old_mr = heap->old_gen()->reserved();
if (young_gen_empty) {
modBS->clear(MemRegion(old_mr.start(), old_mr.end()));
} else {
modBS->invalidate(MemRegion(old_mr.start(), old_mr.end()));
}
// Delete metaspaces for unloaded class loaders and clean up loader_data graph
ClassLoaderDataGraph::purge();
MetaspaceAux::verify_metrics();
BiasedLocking::restore_marks();
CodeCache::gc_epilogue();
JvmtiExport::gc_epilogue();
COMPILER2_PRESENT(DerivedPointerTable::update_pointers());
ref_processor()->enqueue_discovered_references(NULL);
// Update time of last GC
reset_millis_since_last_gc();
// Let the size policy know we're done
size_policy->major_collection_end(old_gen->used_in_bytes(), gc_cause);
if (UseAdaptiveSizePolicy) {
if (PrintAdaptiveSizePolicy) {
gclog_or_tty->print("AdaptiveSizeStart: ");
gclog_or_tty->stamp();
gclog_or_tty->print_cr(" collection: %d ",
heap->total_collections());
if (Verbose) {
gclog_or_tty->print("old_gen_capacity: " SIZE_FORMAT
" young_gen_capacity: " SIZE_FORMAT,
old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes());
}
}
// Don't check if the size_policy is ready here. Let
// the size_policy check that internally.
if (UseAdaptiveGenerationSizePolicyAtMajorCollection &&
((gc_cause != GCCause::_java_lang_system_gc) ||
UseAdaptiveSizePolicyWithSystemGC)) {
// Swap the survivor spaces if from_space is empty. The
// resize_young_gen() called below is normally used after
// a successful young GC and swapping of survivor spaces;
// otherwise, it will fail to resize the young gen with
// the current implementation.
if (young_gen->from_space()->is_empty()) {
young_gen->from_space()->clear(SpaceDecorator::Mangle);
young_gen->swap_spaces();
}
// Calculate optimal free space amounts
assert(young_gen->max_size() >
young_gen->from_space()->capacity_in_bytes() +
young_gen->to_space()->capacity_in_bytes(),
"Sizes of space in young gen are out-of-bounds");
size_t young_live = young_gen->used_in_bytes();
size_t eden_live = young_gen->eden_space()->used_in_bytes();
size_t old_live = old_gen->used_in_bytes();
size_t cur_eden = young_gen->eden_space()->capacity_in_bytes();
size_t max_old_gen_size = old_gen->max_gen_size();
size_t max_eden_size = young_gen->max_size() -
young_gen->from_space()->capacity_in_bytes() -
young_gen->to_space()->capacity_in_bytes();
// Used for diagnostics
size_policy->clear_generation_free_space_flags();
size_policy->compute_generations_free_space(young_live,
eden_live,
old_live,
cur_eden,
max_old_gen_size,
max_eden_size,
true /* full gc*/);
size_policy->check_gc_overhead_limit(young_live,
eden_live,
max_old_gen_size,
max_eden_size,
true /* full gc*/,
gc_cause,
heap->collector_policy());
size_policy->decay_supplemental_growth(true /* full gc*/);
heap->resize_old_gen(size_policy->calculated_old_free_size_in_bytes());
heap->resize_young_gen(size_policy->calculated_eden_size_in_bytes(),
size_policy->calculated_survivor_size_in_bytes());
}
if (PrintAdaptiveSizePolicy) {
gclog_or_tty->print_cr("AdaptiveSizeStop: collection: %d ",
heap->total_collections());
}
}
if (UsePerfData) {
heap->gc_policy_counters()->update_counters();
heap->gc_policy_counters()->update_old_capacity(
old_gen->capacity_in_bytes());
heap->gc_policy_counters()->update_young_capacity(
young_gen->capacity_in_bytes());
}
heap->resize_all_tlabs();
// We collected the heap, recalculate the metaspace capacity
MetaspaceGC::compute_new_size();
if (TraceOldGenTime) accumulated_time()->stop();
if (PrintGC) {
if (PrintGCDetails) {
// Don't print a GC timestamp here. This is after the GC so
// would be confusing.
young_gen->print_used_change(young_gen_prev_used);
old_gen->print_used_change(old_gen_prev_used);
}
heap->print_heap_change(prev_used);
if (PrintGCDetails) {
MetaspaceAux::print_metaspace_change(metadata_prev_used);
}
}
// Track memory usage and detect low memory
MemoryService::track_memory_usage();
heap->update_counters();
}
if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
Universe::verify(" VerifyAfterGC:");
}
// Re-verify object start arrays
if (VerifyObjectStartArray &&
VerifyAfterGC) {
old_gen->verify_object_start_array();
}
if (ZapUnusedHeapArea) {
old_gen->object_space()->check_mangled_unused_area_complete();
}
NOT_PRODUCT(ref_processor()->verify_no_references_recorded());
heap->print_heap_after_gc();
heap->trace_heap_after_gc(_gc_tracer);
heap->post_full_gc_dump(_gc_timer);
#ifdef TRACESPINNING
ParallelTaskTerminator::print_termination_counts();
#endif
_gc_timer->register_gc_end();
_gc_tracer->report_gc_end(_gc_timer->gc_end(), _gc_timer->time_partitions());
return true;
}
//
// ARGUMENT PARSING AND PROGRAM SETUP
//
sysdig_init_res sysdig_init(int argc, char **argv)
{
sysdig_init_res res;
sinsp* inspector = NULL;
vector<string> infiles;
string outfile;
int op;
uint64_t cnt = -1;
bool quiet = false;
bool is_filter_display = false;
bool verbose = false;
bool list_flds = false;
bool list_flds_markdown = false;
bool print_progress = false;
bool compress = false;
sinsp_evt::param_fmt event_buffer_format = sinsp_evt::PF_NORMAL;
sinsp_filter* display_filter = NULL;
double duration = 1;
int duration_to_tot = 0;
captureinfo cinfo;
string output_format;
uint32_t snaplen = 0;
int long_index = 0;
int32_t n_filterargs = 0;
int cflag = 0;
bool jflag = false;
bool unbuf_flag = false;
bool filter_proclist_flag = false;
string cname;
vector<summary_table_entry>* summary_table = NULL;
string* k8s_api = 0;
string* k8s_api_cert = 0;
string* mesos_api = 0;
// These variables are for the cycle_writer engine
int duration_seconds = 0;
int rollover_mb = 0;
int file_limit = 0;
unsigned long event_limit = 0L;
static struct option long_options[] =
{
{"print-ascii", no_argument, 0, 'A' },
{"print-base64", no_argument, 0, 'b' },
#ifdef HAS_CHISELS
{"chisel", required_argument, 0, 'c' },
{"list-chisels", no_argument, &cflag, 1 },
#endif
{"displayflt", no_argument, 0, 'd' },
{"debug", no_argument, 0, 'D'},
{"exclude-users", no_argument, 0, 'E' },
{"event-limit", required_argument, 0, 'e'},
{"fatfile", no_argument, 0, 'F'},
{"filter-proclist", no_argument, 0, 0 },
{"seconds", required_argument, 0, 'G' },
{"help", no_argument, 0, 'h' },
#ifdef HAS_CHISELS
{"chisel-info", required_argument, 0, 'i' },
#endif
{"file-size", required_argument, 0, 'C' },
{"json", no_argument, 0, 'j' },
{"k8s-api", required_argument, 0, 'k'},
{"k8s-api-cert", required_argument, 0, 'K' },
{"list", no_argument, 0, 'l' },
{"list-events", no_argument, 0, 'L' },
{"list-markdown", no_argument, 0, 0 },
{"mesos-api", required_argument, 0, 'm'},
{"numevents", required_argument, 0, 'n' },
{"progress", required_argument, 0, 'P' },
{"print", required_argument, 0, 'p' },
{"quiet", no_argument, 0, 'q' },
{"readfile", required_argument, 0, 'r' },
{"snaplen", required_argument, 0, 's' },
{"summary", no_argument, 0, 'S' },
{"timetype", required_argument, 0, 't' },
{"unbuffered", no_argument, 0, 0 },
{"verbose", no_argument, 0, 'v' },
{"version", no_argument, 0, 0 },
{"writefile", required_argument, 0, 'w' },
{"limit", required_argument, 0, 'W' },
{"print-hex", no_argument, 0, 'x'},
{"print-hex-ascii", no_argument, 0, 'X'},
{"compress", no_argument, 0, 'z' },
{0, 0, 0, 0}
};
output_format = "*%evt.num %evt.outputtime %evt.cpu %proc.name (%thread.tid) %evt.dir %evt.type %evt.info";
try
{
inspector = new sinsp();
#ifdef HAS_CHISELS
add_chisel_dirs(inspector);
#endif
//
// Parse the args
//
while((op = getopt_long(argc, argv,
"Abc:"
"C:"
"dDEe:F"
"G:"
"hi:jk:K:lLm:M:Nn:Pp:qr:Ss:t:v"
"W:"
"w:xXz", long_options, &long_index)) != -1)
{
switch(op)
{
case 'A':
if(event_buffer_format != sinsp_evt::PF_NORMAL)
{
fprintf(stderr, "you cannot specify more than one output format\n");
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
}
event_buffer_format = sinsp_evt::PF_EOLS;
break;
case 'b':
if(event_buffer_format != sinsp_evt::PF_NORMAL)
{
fprintf(stderr, "you cannot specify more than one output format\n");
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
}
event_buffer_format = sinsp_evt::PF_BASE64;
break;
case 0:
if(cflag != 1 && cflag != 2)
{
break;
}
if(cflag == 2)
{
cname = optarg;
}
#ifdef HAS_CHISELS
case 'c':
{
if(cflag == 0)
{
string ostr(optarg);
if(ostr.size() >= 1)
{
if(ostr == "l")
{
cflag = 1;
}
}
}
if(cflag == 1)
{
vector<chisel_desc> chlist;
sinsp_chisel::get_chisel_list(&chlist);
list_chisels(&chlist, true);
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
}
sinsp_chisel* ch = new sinsp_chisel(inspector, optarg);
parse_chisel_args(ch, inspector, optind, argc, argv, &n_filterargs);
g_chisels.push_back(ch);
}
#endif
break;
// File-size
case 'C':
rollover_mb = atoi(optarg);
if(rollover_mb <= 0)
{
throw sinsp_exception(string("invalid file size") + optarg);
res.m_res = EXIT_FAILURE;
goto exit;
}
break;
case 'D':
inspector->set_debug_mode(true);
inspector->set_log_stderr();
break;
case 'E':
inspector->set_import_users(false);
break;
case 'e':
event_limit = strtoul(optarg, NULL, 0);
if(event_limit <= 0)
{
throw sinsp_exception(string("invalid parameter 'number of events' ") + optarg);
res.m_res = EXIT_FAILURE;
goto exit;
}
break;
case 'F':
inspector->set_fatfile_dump_mode(true);
break;
// Number of seconds between roll-over
case 'G':
duration_seconds = atoi(optarg);
if(duration_seconds <= 0)
{
throw sinsp_exception(string("invalid duration") + optarg);
res.m_res = EXIT_FAILURE;
goto exit;
}
break;
#ifdef HAS_CHISELS
// --chisel-info and -i
case 'i':
{
cname = optarg;
vector<chisel_desc> chlist;
sinsp_chisel::get_chisel_list(&chlist);
for(uint32_t j = 0; j < chlist.size(); j++)
{
if(chlist[j].m_name == cname)
{
print_chisel_info(&chlist[j]);
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
}
}
throw sinsp_exception("chisel " + cname + " not found - use -cl to list them.");
}
break;
#endif
case 'd':
is_filter_display = true;
break;
case 'j':
//
// set the json flag to 1 for now, the data format will depend from the print format parameters
//
jflag = true;
break;
case 'k':
k8s_api = new string(optarg);
break;
case 'K':
k8s_api_cert = new string(optarg);
break;
case 'h':
usage();
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
case 'l':
list_flds = true;
break;
case 'L':
list_events(inspector);
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
case 'm':
mesos_api = new string(optarg);
break;
case 'M':
duration_to_tot = atoi(optarg);
if(duration_to_tot <= 0)
{
throw sinsp_exception(string("invalid duration") + optarg);
res.m_res = EXIT_FAILURE;
goto exit;
}
break;
case 'N':
inspector->set_hostname_and_port_resolution_mode(false);
break;
case 'n':
try
{
cnt = sinsp_numparser::parseu64(optarg);
}
catch(...)
{
throw sinsp_exception("can't parse the -n argument, make sure it's a number");
}
if(cnt <= 0)
{
throw sinsp_exception(string("invalid event count ") + optarg);
res.m_res = EXIT_FAILURE;
goto exit;
}
break;
case 'P':
print_progress = true;
break;
case 'p':
if(string(optarg) == "p")
{
// -pp shows the default output format, useful if the user wants to tweak it.
printf("%s\n", output_format.c_str());
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
}
else if(string(optarg) == "c" || string(optarg) == "container")
{
output_format = "*%evt.num %evt.outputtime %evt.cpu %container.name (%container.id) %proc.name (%thread.tid:%thread.vtid) %evt.dir %evt.type %evt.info";
// This enables chisels to determine if they should print container information
if(inspector != NULL)
{
inspector->set_print_container_data(true);
}
}
else if(string(optarg) == "k" || string(optarg) == "kubernetes")
{
output_format = "*%evt.num %evt.outputtime %evt.cpu %k8s.pod.name (%container.id) %proc.name (%thread.tid:%thread.vtid) %evt.dir %evt.type %evt.info";
// This enables chisels to determine if they should print container information
if(inspector != NULL)
{
inspector->set_print_container_data(true);
}
}
else if(string(optarg) == "m" || string(optarg) == "mesos")
{
output_format = "*%evt.num %evt.outputtime %evt.cpu %mesos.task.name (%container.id) %proc.name (%thread.tid:%thread.vtid) %evt.dir %evt.type %evt.info";
// This enables chisels to determine if they should print container information
if(inspector != NULL)
{
inspector->set_print_container_data(true);
}
}
else
{
output_format = optarg;
}
break;
case 'q':
quiet = true;
break;
case 'r':
infiles.push_back(optarg);
k8s_api = new string();
mesos_api = new string();
break;
case 'S':
summary_table = new vector<summary_table_entry>;
for(uint32_t j = 0; j < PPM_EVENT_MAX; j++)
{
summary_table->push_back(summary_table_entry(j, false));
}
for(uint32_t j = 0; j < PPM_SC_MAX * 2; j++)
{
summary_table->push_back(summary_table_entry(j, true));
}
break;
case 's':
snaplen = atoi(optarg);
break;
case 't':
{
string tms(optarg);
if(tms == "h" || tms == "a" || tms == "r" || tms == "d" || tms == "D")
{
inspector->set_time_output_mode(tms.c_str()[0]);
}
else
{
fprintf(stderr, "invalid modifier for flag -t\n");
delete inspector;
return sysdig_init_res(EXIT_FAILURE);
}
}
break;
case 'v':
verbose = true;
break;
case 'w':
outfile = optarg;
quiet = true;
break;
// Number of capture files to cycle through
case 'W':
file_limit = atoi(optarg);
if(file_limit <= 0)
{
throw sinsp_exception(string("invalid file limit") + optarg);
res.m_res = EXIT_FAILURE;
goto exit;
}
break;
case 'x':
if(event_buffer_format != sinsp_evt::PF_NORMAL)
{
fprintf(stderr, "you cannot specify more than one output format\n");
delete inspector;
return sysdig_init_res(EXIT_FAILURE);
}
event_buffer_format = sinsp_evt::PF_HEX;
break;
case 'X':
if(event_buffer_format != sinsp_evt::PF_NORMAL)
{
fprintf(stderr, "you cannot specify more than one output format\n");
delete inspector;
return sysdig_init_res(EXIT_FAILURE);
}
event_buffer_format = sinsp_evt::PF_HEXASCII;
break;
case 'z':
compress = true;
break;
// getopt_long : '?' for an ambiguous match or an extraneous parameter
case '?':
delete inspector;
return sysdig_init_res(EXIT_FAILURE);
break;
default:
break;
}
if(string(long_options[long_index].name) == "version")
{
printf("sysdig version %s\n", SYSDIG_VERSION);
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
}
if(string(long_options[long_index].name) == "unbuffered")
{
unbuf_flag = true;
}
if(string(long_options[long_index].name) == "filter-proclist")
{
filter_proclist_flag = true;
}
if(string(long_options[long_index].name) == "list-markdown")
{
list_flds = true;
list_flds_markdown = true;
}
}
//
// If -j was specified the event_buffer_format must be rewritten to account for it
//
if(jflag)
{
switch (event_buffer_format)
{
case sinsp_evt::PF_NORMAL:
event_buffer_format = sinsp_evt::PF_JSON;
break;
case sinsp_evt::PF_EOLS:
event_buffer_format = sinsp_evt::PF_JSONEOLS;
break;
case sinsp_evt::PF_HEX:
event_buffer_format = sinsp_evt::PF_JSONHEX;
break;
case sinsp_evt::PF_HEXASCII:
event_buffer_format = sinsp_evt::PF_JSONHEXASCII;
break;
case sinsp_evt::PF_BASE64:
event_buffer_format = sinsp_evt::PF_JSONBASE64;
break;
default:
// do nothing
break;
}
}
inspector->set_buffer_format(event_buffer_format);
//
// If -l was specified, print the fields and exit
//
if(list_flds)
{
if(verbose)
{
//
// -ll shows the fields verbosely, i.e. with more information
// like the type
//
list_fields(true, list_flds_markdown);
}
else
{
list_fields(false, list_flds_markdown);
}
res.m_res = EXIT_SUCCESS;
goto exit;
}
string filter;
//
// the filter is at the end of the command line
//
if(optind + n_filterargs < argc)
{
#ifdef HAS_FILTERING
for(int32_t j = optind + n_filterargs; j < argc; j++)
{
filter += argv[j];
if(j < argc - 1)
{
filter += " ";
}
}
if(is_filter_display)
{
sinsp_filter_compiler compiler(inspector, filter);
display_filter = compiler.compile();
}
#else
fprintf(stderr, "filtering not compiled.\n");
res.m_res = EXIT_FAILURE;
goto exit;
#endif
}
if(signal(SIGINT, signal_callback) == SIG_ERR)
{
fprintf(stderr, "An error occurred while setting SIGINT signal handler.\n");
res.m_res = EXIT_FAILURE;
goto exit;
}
if(signal(SIGTERM, signal_callback) == SIG_ERR)
{
fprintf(stderr, "An error occurred while setting SIGTERM signal handler.\n");
res.m_res = EXIT_FAILURE;
goto exit;
}
//
// Create the event formatter
//
sinsp_evt_formatter formatter(inspector, output_format);
//
// Set output buffers len
//
if(!verbose && g_chisels.size() == 0)
{
inspector->set_max_evt_output_len(80);
}
//
// Determine if we need to filter when dumping to file
//
if(filter_proclist_flag)
{
if(filter != "")
{
if(infiles.size() == 0)
{
fprintf(stderr, "--filter-proclist not supported with live captures.\n");
res.m_res = EXIT_FAILURE;
goto exit;
}
inspector->filter_proc_table_when_saving(true);
}
else
{
fprintf(stderr, "you must specify a filter if you use --filter-proclist.\n");
res.m_res = EXIT_FAILURE;
goto exit;
}
}
for(uint32_t j = 0; j < infiles.size() || infiles.size() == 0; j++)
{
#ifdef HAS_FILTERING
if(filter.size() && !is_filter_display)
{
inspector->set_filter(filter);
}
#endif
//
// Launch the capture
//
if(infiles.size() != 0)
{
initialize_chisels();
//
// We have a file to open
//
inspector->open(infiles[j]);
}
else
{
if(j > 0)
{
break;
}
initialize_chisels();
//
// No file to open, this is a live capture
//
#if defined(HAS_CAPTURE)
bool open_success = true;
if(print_progress)
{
fprintf(stderr, "the -P flag cannot be used with live captures.\n");
res.m_res = EXIT_FAILURE;
goto exit;
}
try
{
inspector->open("");
}
catch(sinsp_exception e)
{
open_success = false;
}
//
// Starting the live capture failed, try to load the driver with
// modprobe.
//
if(!open_success)
{
open_success = true;
if(system("modprobe " PROBE_NAME " > /dev/null 2> /dev/null"))
{
fprintf(stderr, "Unable to load the driver\n");
}
inspector->open("");
}
#else
//
// Starting live capture
// If this fails on Windows and OSX, don't try with any driver
//
inspector->open("");
#endif
//
// Enable gathering the CPU from the kernel module
//
inspector->set_get_procs_cpu_from_driver(true);
}
if(snaplen != 0)
{
inspector->set_snaplen(snaplen);
}
duration = ((double)clock()) / CLOCKS_PER_SEC;
if(outfile != "")
{
inspector->setup_cycle_writer(outfile, rollover_mb, duration_seconds, file_limit, event_limit, compress);
inspector->autodump_next_file();
}
//
// Notify the chisels that the capture is starting
//
chisels_on_capture_start();
//
// run k8s, if required
//
if(k8s_api)
{
if(!k8s_api_cert)
{
if(char* k8s_cert_env = getenv("SYSDIG_K8S_API_CERT"))
{
k8s_api_cert = new string(k8s_cert_env);
}
}
inspector->init_k8s_client(k8s_api, k8s_api_cert, verbose);
k8s_api = 0;
k8s_api_cert = 0;
}
else if(char* k8s_api_env = getenv("SYSDIG_K8S_API"))
{
if(k8s_api_env != NULL)
{
if(!k8s_api_cert)
{
if(char* k8s_cert_env = getenv("SYSDIG_K8S_API_CERT"))
{
k8s_api_cert = new string(k8s_cert_env);
}
}
k8s_api = new string(k8s_api_env);
inspector->init_k8s_client(k8s_api, k8s_api_cert, verbose);
}
else
{
delete k8s_api;
delete k8s_api_cert;
}
k8s_api = 0;
k8s_api_cert = 0;
}
//
// run mesos, if required
//
if(mesos_api)
{
inspector->init_mesos_client(mesos_api, verbose);
}
else if(char* mesos_api_env = getenv("SYSDIG_MESOS_API"))
{
if(mesos_api_env != NULL)
{
mesos_api = new string(mesos_api_env);
inspector->init_mesos_client(mesos_api, verbose);
}
}
delete mesos_api;
mesos_api = 0;
cinfo = do_inspect(inspector,
cnt,
duration_to_tot,
quiet,
jflag,
unbuf_flag,
print_progress,
display_filter,
summary_table,
&formatter);
duration = ((double)clock()) / CLOCKS_PER_SEC - duration;
scap_stats cstats;
inspector->get_capture_stats(&cstats);
if(verbose)
{
fprintf(stderr, "Driver Events:%" PRIu64 "\nDriver Drops:%" PRIu64 "\n",
cstats.n_evts,
cstats.n_drops);
fprintf(stderr, "Elapsed time: %.3lf, Captured Events: %" PRIu64 ", %.2lf eps\n",
duration,
cinfo.m_nevts,
(double)cinfo.m_nevts / duration);
}
//
// Done. Close the capture.
//
inspector->close();
}
}
catch(sinsp_capture_interrupt_exception&)
{
handle_end_of_file(print_progress);
}
catch(sinsp_exception& e)
{
cerr << e.what() << endl;
handle_end_of_file(print_progress);
res.m_res = EXIT_FAILURE;
}
catch(...)
{
handle_end_of_file(print_progress);
res.m_res = EXIT_FAILURE;
}
exit:
//
// If any of the chisels is requesting another run,
//
for(vector<sinsp_chisel*>::iterator it = g_chisels.begin();
it != g_chisels.end(); ++it)
{
string na;
if((*it)->get_nextrun_args(&na))
{
res.m_next_run_args = sinsp_split(na, ' ');
}
}
//
// If there's a summary table, sort and print it
//
if(summary_table != NULL)
{
print_summary_table(inspector, summary_table, 100);
}
//
// Free all the stuff that was allocated
//
free_chisels();
if(inspector)
{
delete inspector;
}
if(display_filter)
{
delete display_filter;
}
return res;
}
//
// MAIN
//
int main(int argc, char **argv)
{
int res = EXIT_SUCCESS;
sinsp* inspector = NULL;
vector<string> infiles;
string outfile;
int op;
uint64_t cnt = -1;
bool quiet = false;
bool absolute_times = false;
bool is_filter_display = false;
bool verbose = false;
bool list_flds = false;
bool print_progress = false;
bool compress = false;
sinsp_evt::param_fmt event_buffer_format = sinsp_evt::PF_NORMAL;
sinsp_filter* display_filter = NULL;
double duration = 1;
captureinfo cinfo;
string output_format;
uint32_t snaplen = 0;
int long_index = 0;
int32_t n_filterargs = 0;
int cflag = 0;
string cname;
vector<summary_table_entry>* summary_table = NULL;
string timefmt = "%evt.time";
static struct option long_options[] =
{
{"print-ascii", no_argument, 0, 'A' },
{"abstimes", no_argument, 0, 'a' },
#ifdef HAS_CHISELS
{"chisel", required_argument, 0, 'c' },
{"list-chisels", no_argument, &cflag, 1 },
#endif
{"compress", no_argument, 0, 'z' },
{"displayflt", no_argument, 0, 'd' },
{"debug", no_argument, 0, 'D'},
{"help", no_argument, 0, 'h' },
#ifdef HAS_CHISELS
{"chisel-info", required_argument, 0, 'i' },
#endif
{"json", no_argument, 0, 'j' },
{"list", no_argument, 0, 'l' },
{"list-events", no_argument, 0, 'L' },
{"numevents", required_argument, 0, 'n' },
{"progress", required_argument, 0, 'P' },
{"print", required_argument, 0, 'p' },
{"quiet", no_argument, 0, 'q' },
{"readfile", required_argument, 0, 'r' },
{"snaplen", required_argument, 0, 's' },
{"summary", no_argument, 0, 'S' },
{"timetype", required_argument, 0, 't' },
{"verbose", no_argument, 0, 'v' },
{"writefile", required_argument, 0, 'w' },
{"print-hex", no_argument, 0, 'x'},
{"print-hex-ascii", no_argument, 0, 'X'},
{0, 0, 0, 0}
};
output_format = "*%evt.num <TIME> %evt.cpu %proc.name (%thread.tid) %evt.dir %evt.type %evt.args";
// output_format = DEFAULT_OUTPUT_STR;
try
{
inspector = new sinsp();
#ifdef HAS_CHISELS
add_chisel_dirs(inspector);
#endif
//
// Parse the args
//
while((op = getopt_long(argc, argv, "Aac:dDhi:jlLn:Pp:qr:Ss:t:vw:xXz", long_options, &long_index)) != -1)
{
switch(op)
{
case 'A':
if(event_buffer_format != sinsp_evt::PF_NORMAL)
{
fprintf(stderr, "you cannot specify more than one output format\n");
delete inspector;
return EXIT_SUCCESS;
}
event_buffer_format = sinsp_evt::PF_EOLS;
break;
case 'a':
absolute_times = true;
break;
case 0:
if(cflag != 1 && cflag != 2)
{
break;
}
if(cflag == 2)
{
cname = optarg;
}
#ifdef HAS_CHISELS
case 'c':
{
if(cflag == 0)
{
string ostr(optarg);
if(ostr.size() >= 1)
{
if(ostr == "l")
{
cflag = 1;
}
}
}
if(cflag == 1)
{
vector<chisel_desc> chlist;
sinsp_chisel::get_chisel_list(&chlist);
list_chisels(&chlist, true);
delete inspector;
return EXIT_SUCCESS;
}
sinsp_chisel* ch = new sinsp_chisel(inspector, optarg);
parse_chisel_args(ch, inspector, optind, argc, argv, &n_filterargs);
g_chisels.push_back(ch);
}
#endif
break;
case 'D':
inspector->set_debug_mode(true);
break;
#ifdef HAS_CHISELS
// --chisel-info and -i
case 'i':
{
cname = optarg;
vector<chisel_desc> chlist;
sinsp_chisel::get_chisel_list(&chlist);
for(uint32_t j = 0; j < chlist.size(); j++)
{
if(chlist[j].m_name == cname)
{
print_chisel_info(&chlist[j]);
delete inspector;
return EXIT_SUCCESS;
}
}
throw sinsp_exception("chisel " + cname + " not found - use -cl to list them.");
}
break;
#endif
case 'd':
is_filter_display = true;
break;
case 'j':
// throw sinsp_exception("json output not yet implemented");
if(event_buffer_format != sinsp_evt::PF_NORMAL)
{
fprintf(stderr, "you cannot specify more than one output format\n");
delete inspector;
return EXIT_SUCCESS;
}
event_buffer_format = sinsp_evt::PF_JSON;
break;
case 'h':
usage();
delete inspector;
return EXIT_SUCCESS;
case 'l':
list_flds = true;
break;
case 'L':
list_events(inspector);
delete inspector;
return EXIT_SUCCESS;
case 'n':
cnt = atoi(optarg);
if(cnt <= 0)
{
throw sinsp_exception(string("invalid packet count") + optarg);
res = EXIT_FAILURE;
goto exit;
}
break;
case 'P':
print_progress = true;
break;
case 'p':
if(string(optarg) == "p")
{
//
// -pp shows the default output format, useful if the user wants to tweak it.
//
replace_in_place(output_format, "<TIME>", timefmt);
printf("%s\n", output_format.c_str());
delete inspector;
return EXIT_SUCCESS;
}
else
{
output_format = optarg;
}
break;
case 'q':
quiet = true;
break;
case 'r':
infiles.push_back(optarg);
break;
case 'S':
summary_table = new vector<summary_table_entry>;
for(uint32_t j = 0; j < PPM_EVENT_MAX; j++)
{
summary_table->push_back(summary_table_entry(j, false));
}
for(uint32_t j = 0; j < PPM_SC_MAX * 2; j++)
{
summary_table->push_back(summary_table_entry(j, true));
}
break;
case 's':
snaplen = atoi(optarg);
break;
case 't':
{
string tms(optarg);
if(tms == "h")
{
timefmt = "%evt.time";
}
else if(tms == "a")
{
timefmt = "%evt.rawtime.s.%evt.rawtime.ns";
}
else if(tms == "r")
{
timefmt = "%evt.reltime.s.%evt.reltime.ns";
}
else if(tms == "d")
{
timefmt = "%evt.latency.s.%evt.latency.ns";
}
}
break;
case 'v':
verbose = true;
break;
case 'w':
outfile = optarg;
quiet = true;
break;
case 'x':
if(event_buffer_format != sinsp_evt::PF_NORMAL)
{
fprintf(stderr, "you cannot specify more than one output format\n");
delete inspector;
return EXIT_SUCCESS;
}
event_buffer_format = sinsp_evt::PF_HEX;
break;
case 'X':
if(event_buffer_format != sinsp_evt::PF_NORMAL)
{
fprintf(stderr, "you cannot specify more than one output format\n");
delete inspector;
return EXIT_SUCCESS;
}
event_buffer_format = sinsp_evt::PF_HEXASCII;
break;
case 'z':
compress = true;
break;
default:
break;
}
}
inspector->set_buffer_format(event_buffer_format);
//
// If -l was specified, print the fields and exit
//
if(list_flds)
{
if(verbose)
{
//
// -ll shows the fields verbosely, i.e. with more information
// like the type
//
list_fields(true);
}
else
{
list_fields(false);
}
res = EXIT_SUCCESS;
goto exit;
}
string filter;
//
// the filter is at the end of the command line
//
if(optind + n_filterargs < argc)
{
#ifdef HAS_FILTERING
for(int32_t j = optind + n_filterargs; j < argc; j++)
{
filter += argv[j];
if(j < argc)
{
filter += " ";
}
}
if(is_filter_display)
{
display_filter = new sinsp_filter(inspector, filter);
}
#else
fprintf(stderr, "filtering not compiled.\n");
res = EXIT_FAILURE;
goto exit;
#endif
}
if(signal(SIGINT, signal_callback) == SIG_ERR)
{
fprintf(stderr, "An error occurred while setting SIGINT signal handler.\n");
res = EXIT_FAILURE;
goto exit;
}
if(signal(SIGTERM, signal_callback) == SIG_ERR)
{
fprintf(stderr, "An error occurred while setting SIGTERM signal handler.\n");
res = EXIT_FAILURE;
goto exit;
}
//
// Insert the right time format based on the -t flag
//
replace_in_place(output_format, "<TIME>", timefmt);
//
// Create the event formatter
//
sinsp_evt_formatter formatter(inspector, output_format);
for(uint32_t j = 0; j < infiles.size() || infiles.size() == 0; j++)
{
#ifdef HAS_FILTERING
if(filter.size() && !is_filter_display)
{
inspector->set_filter(filter);
}
#endif
//
// Launch the capture
//
bool open_success = true;
if(infiles.size() != 0)
{
initialize_chisels();
//
// We have a file to open
//
inspector->open(infiles[j]);
}
else
{
if(j > 0)
{
break;
}
initialize_chisels();
//
// No file to open, this is a live capture
//
#if defined(HAS_CAPTURE)
if(print_progress)
{
fprintf(stderr, "the -P flag cannot be used with live captures.\n");
res = EXIT_FAILURE;
goto exit;
}
try
{
inspector->open("");
}
catch(sinsp_exception e)
{
open_success = false;
}
#else
//
// Starting live capture
// If this fails on Windows and OSX, don't try with any driver
//
inspector->open("");
#endif
//
// Starting the live capture failed, try to load the driver with
// modprobe.
//
if(!open_success)
{
open_success = true;
system("modprobe sysdig-probe > /dev/null 2> /dev/null");
inspector->open("");
}
}
if(snaplen != 0)
{
inspector->set_snaplen(snaplen);
}
duration = ((double)clock()) / CLOCKS_PER_SEC;
if(outfile != "")
{
inspector->autodump_start(outfile, compress);
}
//
// Notify the chisels that the capture is starting
//
chisels_on_capture_start();
cinfo = do_inspect(inspector,
cnt,
quiet,
absolute_times,
print_progress,
display_filter,
summary_table,
&formatter);
duration = ((double)clock()) / CLOCKS_PER_SEC - duration;
scap_stats cstats;
inspector->get_capture_stats(&cstats);
if(verbose)
{
fprintf(stderr, "Driver Events:%" PRIu64 "\nDriver Drops:%" PRIu64 "\n",
cstats.n_evts,
cstats.n_drops);
fprintf(stderr, "Elapsed time: %.3lf, Captured Events: %" PRIu64 ", %.2lf eps\n",
duration,
cinfo.m_nevts,
(double)cinfo.m_nevts / duration);
}
//
// Done. Close the capture.
//
inspector->close();
}
}
catch(sinsp_exception& e)
{
cerr << e.what() << endl;
handle_end_of_file(print_progress);
res = EXIT_FAILURE;
}
catch(...)
{
handle_end_of_file(print_progress);
res = EXIT_FAILURE;
}
exit:
//
// If there's a summary table, sort and print it
//
if(summary_table != NULL)
{
print_summary_table(inspector, summary_table, 100);
}
free_chisels();
if(inspector)
{
delete inspector;
}
if(display_filter)
{
delete display_filter;
}
#ifdef _WIN32
_CrtDumpMemoryLeaks();
#endif
return res;
}
void mrgame_state::mrgame(machine_config &config)
{
/* basic machine hardware */
M68000(config, m_maincpu, 6_MHz_XTAL);
m_maincpu->set_addrmap(AS_PROGRAM, &mrgame_state::main_map);
m_maincpu->set_periodic_int(FUNC(mrgame_state::irq1_line_hold), attotime::from_hz(183));
Z80(config, m_videocpu, 18.432_MHz_XTAL / 6);
m_videocpu->set_addrmap(AS_PROGRAM, &mrgame_state::video_map);
Z80(config, m_audiocpu1, 4_MHz_XTAL);
m_audiocpu1->set_addrmap(AS_PROGRAM, &mrgame_state::audio1_map);
m_audiocpu1->set_addrmap(AS_IO, &mrgame_state::audio1_io);
Z80(config, m_audiocpu2, 4_MHz_XTAL);
m_audiocpu2->set_addrmap(AS_PROGRAM, &mrgame_state::audio2_map);
m_audiocpu2->set_addrmap(AS_IO, &mrgame_state::audio2_io);
NVRAM(config, "nvram", nvram_device::DEFAULT_ALL_0); // 5564 (x2) + battery
LS259(config, m_selectlatch); // 5B
m_selectlatch->q_out_cb<0>().set(FUNC(mrgame_state::video_a11_w));
m_selectlatch->q_out_cb<1>().set(FUNC(mrgame_state::nmi_intst_w));
m_selectlatch->q_out_cb<3>().set(FUNC(mrgame_state::video_a12_w));
m_selectlatch->q_out_cb<4>().set(FUNC(mrgame_state::video_a13_w));
m_selectlatch->q_out_cb<6>().set(FUNC(mrgame_state::flip_w));
//watchdog_timer_device &watchdog(WATCHDOG_TIMER(config, "watchdog")); // LS393 at 5D (video board) driven by VBLANK
//watchdog.set_vblank_count("screen", 8);
/* video hardware */
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_raw(18.432_MHz_XTAL / 3, 384, 0, 256, 264, 8, 248); // If you align with X on test screen some info is chopped off
screen.set_screen_update(FUNC(mrgame_state::screen_update_mrgame));
screen.set_palette(m_palette);
screen.screen_vblank().set(FUNC(mrgame_state::vblank_nmi_w));
PALETTE(config, m_palette, FUNC(mrgame_state::mrgame_palette), 64);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_mrgame);
/* Sound */
SPEAKER(config, "lspeaker").front_left();
SPEAKER(config, "rspeaker").front_right();
DAC_8BIT_R2R(config, "ldac", 0).add_route(ALL_OUTPUTS, "lspeaker", 0.25); // unknown DAC
DAC_8BIT_R2R(config, "rdac", 0).add_route(ALL_OUTPUTS, "rspeaker", 0.25); // unknown DAC
dac_8bit_r2r_device &dacvol(DAC_8BIT_R2R(config, "dacvol", 0)); // unknown DAC
dacvol.add_route(0, "ldac", 1.0, DAC_VREF_POS_INPUT);
dacvol.add_route(0, "ldac", -1.0, DAC_VREF_NEG_INPUT);
dacvol.add_route(0, "rdac", 1.0, DAC_VREF_POS_INPUT);
dacvol.add_route(0, "rdac", -1.0, DAC_VREF_NEG_INPUT);
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref", 0));
vref.set_output(5.0);
vref.add_route(0, "dacvol", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dacvol", -1.0, DAC_VREF_NEG_INPUT);
tms5220_device &tms(TMS5220(config, "tms", 672000)); // uses a RC combination. 672k copied from jedi.h
tms.ready_cb().set_inputline("audiocpu2", Z80_INPUT_LINE_BOGUSWAIT);
tms.add_route(ALL_OUTPUTS, "lspeaker", 1.0);
tms.add_route(ALL_OUTPUTS, "rspeaker", 1.0);
/* Devices */
TIMER(config, "irq_timer").configure_periodic(FUNC(mrgame_state::irq_timer), attotime::from_hz(16000)); //ugh
i8255_device &ppi(I8255A(config, "ppi"));
ppi.in_pa_callback().set(FUNC(mrgame_state::porta_r));
ppi.out_pb_callback().set(FUNC(mrgame_state::portb_w));
ppi.in_pc_callback().set(FUNC(mrgame_state::portc_r));
}
// This method contains no policy. You should probably
// be calling invoke() instead.
bool PSScavenge::invoke_no_policy() {
assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread");
assert(_preserved_mark_stack.is_empty(), "should be empty");
assert(_preserved_oop_stack.is_empty(), "should be empty");
_gc_timer.register_gc_start();
TimeStamp scavenge_entry;
TimeStamp scavenge_midpoint;
TimeStamp scavenge_exit;
scavenge_entry.update();
if (GC_locker::check_active_before_gc()) {
return false;
}
ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
GCCause::Cause gc_cause = heap->gc_cause();
assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");
// Check for potential problems.
if (!should_attempt_scavenge()) {
return false;
}
_gc_tracer.report_gc_start(heap->gc_cause(), _gc_timer.gc_start());
bool promotion_failure_occurred = false;
PSYoungGen* young_gen = heap->young_gen();
PSOldGen* old_gen = heap->old_gen();
PSAdaptiveSizePolicy* size_policy = heap->size_policy();
heap->increment_total_collections();
AdaptiveSizePolicyOutput(size_policy, heap->total_collections());
if ((gc_cause != GCCause::_java_lang_system_gc) ||
UseAdaptiveSizePolicyWithSystemGC) {
// Gather the feedback data for eden occupancy.
young_gen->eden_space()->accumulate_statistics();
}
if (ZapUnusedHeapArea) {
// Save information needed to minimize mangling
heap->record_gen_tops_before_GC();
}
heap->print_heap_before_gc();
heap->trace_heap_before_gc(&_gc_tracer);
assert(!NeverTenure || _tenuring_threshold == markOopDesc::max_age + 1, "Sanity");
assert(!AlwaysTenure || _tenuring_threshold == 0, "Sanity");
size_t prev_used = heap->used();
// Fill in TLABs
heap->accumulate_statistics_all_tlabs();
heap->ensure_parsability(true); // retire TLABs
if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
Universe::verify(" VerifyBeforeGC:");
}
{
ResourceMark rm;
HandleMark hm;
gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps);
TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
GCTraceTime t1(GCCauseString("GC", gc_cause), PrintGC, !PrintGCDetails, NULL);
TraceCollectorStats tcs(counters());
TraceMemoryManagerStats tms(false /* not full GC */,gc_cause);
if (TraceGen0Time) accumulated_time()->start();
// Let the size policy know we're starting
size_policy->minor_collection_begin();
// Verify the object start arrays.
if (VerifyObjectStartArray &&
VerifyBeforeGC) {
old_gen->verify_object_start_array();
}
// Verify no unmarked old->young roots
if (VerifyRememberedSets) {
CardTableExtension::verify_all_young_refs_imprecise();
}
if (!ScavengeWithObjectsInToSpace) {
assert(young_gen->to_space()->is_empty(),
"Attempt to scavenge with live objects in to_space");
young_gen->to_space()->clear(SpaceDecorator::Mangle);
} else if (ZapUnusedHeapArea) {
young_gen->to_space()->mangle_unused_area();
}
save_to_space_top_before_gc();
COMPILER2_PRESENT(DerivedPointerTable::clear());
reference_processor()->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/);
reference_processor()->setup_policy(false);
// We track how much was promoted to the next generation for
// the AdaptiveSizePolicy.
size_t old_gen_used_before = old_gen->used_in_bytes();
// For PrintGCDetails
size_t young_gen_used_before = young_gen->used_in_bytes();
// Reset our survivor overflow.
set_survivor_overflow(false);
// We need to save the old top values before
// creating the promotion_manager. We pass the top
// values to the card_table, to prevent it from
// straying into the promotion labs.
HeapWord* old_top = old_gen->object_space()->top();
// Release all previously held resources
gc_task_manager()->release_all_resources();
// Set the number of GC threads to be used in this collection
gc_task_manager()->set_active_gang();
gc_task_manager()->task_idle_workers();
// Get the active number of workers here and use that value
// throughout the methods.
uint active_workers = gc_task_manager()->active_workers();
heap->set_par_threads(active_workers);
PSPromotionManager::pre_scavenge();
// We'll use the promotion manager again later.
PSPromotionManager* promotion_manager = PSPromotionManager::vm_thread_promotion_manager();
{
GCTraceTime tm("Scavenge", false, false, &_gc_timer);
ParallelScavengeHeap::ParStrongRootsScope psrs;
GCTaskQueue* q = GCTaskQueue::create();
if (!old_gen->object_space()->is_empty()) {
// There are only old-to-young pointers if there are objects
// in the old gen.
uint stripe_total = active_workers;
for(uint i=0; i < stripe_total; i++) {
q->enqueue(new OldToYoungRootsTask(old_gen, old_top, i, stripe_total));
}
}
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::universe));
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::jni_handles));
// We scan the thread roots in parallel
Threads::create_thread_roots_tasks(q);
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::object_synchronizer));
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::flat_profiler));
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::management));
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::system_dictionary));
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::class_loader_data));
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::jvmti));
q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::code_cache));
ParallelTaskTerminator terminator(
active_workers,
(TaskQueueSetSuper*) promotion_manager->stack_array_depth());
if (active_workers > 1) {
for (uint j = 0; j < active_workers; j++) {
q->enqueue(new StealTask(&terminator));
}
}
gc_task_manager()->execute_and_wait(q);
}
scavenge_midpoint.update();
// Process reference objects discovered during scavenge
{
GCTraceTime tm("References", false, false, &_gc_timer);
reference_processor()->setup_policy(false); // not always_clear
reference_processor()->set_active_mt_degree(active_workers);
PSKeepAliveClosure keep_alive(promotion_manager);
PSEvacuateFollowersClosure evac_followers(promotion_manager);
ReferenceProcessorStats stats;
if (reference_processor()->processing_is_mt()) {
PSRefProcTaskExecutor task_executor;
stats = reference_processor()->process_discovered_references(
&_is_alive_closure, &keep_alive, &evac_followers, &task_executor,
&_gc_timer);
} else {
stats = reference_processor()->process_discovered_references(
&_is_alive_closure, &keep_alive, &evac_followers, NULL, &_gc_timer);
}
_gc_tracer.report_gc_reference_stats(stats);
// Enqueue reference objects discovered during scavenge.
if (reference_processor()->processing_is_mt()) {
PSRefProcTaskExecutor task_executor;
reference_processor()->enqueue_discovered_references(&task_executor);
} else {
reference_processor()->enqueue_discovered_references(NULL);
}
}
{
GCTraceTime tm("StringTable", false, false, &_gc_timer);
// Unlink any dead interned Strings and process the remaining live ones.
PSScavengeRootsClosure root_closure(promotion_manager);
StringTable::unlink_or_oops_do(&_is_alive_closure, &root_closure);
}
// Finally, flush the promotion_manager's labs, and deallocate its stacks.
promotion_failure_occurred = PSPromotionManager::post_scavenge(_gc_tracer);
if (promotion_failure_occurred) {
clean_up_failed_promotion();
if (PrintGC) {
gclog_or_tty->print("--");
}
}
// Let the size policy know we're done. Note that we count promotion
// failure cleanup time as part of the collection (otherwise, we're
// implicitly saying it's mutator time).
size_policy->minor_collection_end(gc_cause);
if (!promotion_failure_occurred) {
// Swap the survivor spaces.
young_gen->eden_space()->clear(SpaceDecorator::Mangle);
young_gen->from_space()->clear(SpaceDecorator::Mangle);
young_gen->swap_spaces();
size_t survived = young_gen->from_space()->used_in_bytes();
size_t promoted = old_gen->used_in_bytes() - old_gen_used_before;
size_policy->update_averages(_survivor_overflow, survived, promoted);
// A successful scavenge should restart the GC time limit count which is
// for full GC's.
size_policy->reset_gc_overhead_limit_count();
if (UseAdaptiveSizePolicy) {
// Calculate the new survivor size and tenuring threshold
if (PrintAdaptiveSizePolicy) {
gclog_or_tty->print("AdaptiveSizeStart: ");
gclog_or_tty->stamp();
gclog_or_tty->print_cr(" collection: %d ",
heap->total_collections());
if (Verbose) {
gclog_or_tty->print("old_gen_capacity: %d young_gen_capacity: %d",
old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes());
}
}
if (UsePerfData) {
PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters();
counters->update_old_eden_size(
size_policy->calculated_eden_size_in_bytes());
counters->update_old_promo_size(
size_policy->calculated_promo_size_in_bytes());
counters->update_old_capacity(old_gen->capacity_in_bytes());
counters->update_young_capacity(young_gen->capacity_in_bytes());
counters->update_survived(survived);
counters->update_promoted(promoted);
counters->update_survivor_overflowed(_survivor_overflow);
}
size_t max_young_size = young_gen->max_size();
// Deciding a free ratio in the young generation is tricky, so if
// MinHeapFreeRatio or MaxHeapFreeRatio are in use (implicating
// that the old generation size may have been limited because of them) we
// should then limit our young generation size using NewRatio to have it
// follow the old generation size.
if (MinHeapFreeRatio != 0 || MaxHeapFreeRatio != 100) {
max_young_size = MIN2(old_gen->capacity_in_bytes() / NewRatio, young_gen->max_size());
}
size_t survivor_limit =
size_policy->max_survivor_size(max_young_size);
_tenuring_threshold =
size_policy->compute_survivor_space_size_and_threshold(
_survivor_overflow,
_tenuring_threshold,
survivor_limit);
if (PrintTenuringDistribution) {
gclog_or_tty->cr();
gclog_or_tty->print_cr("Desired survivor size " SIZE_FORMAT " bytes, new threshold %u (max %u)",
size_policy->calculated_survivor_size_in_bytes(),
_tenuring_threshold, MaxTenuringThreshold);
}
if (UsePerfData) {
PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters();
counters->update_tenuring_threshold(_tenuring_threshold);
counters->update_survivor_size_counters();
}
// Do call at minor collections?
// Don't check if the size_policy is ready at this
// level. Let the size_policy check that internally.
if (UseAdaptiveGenerationSizePolicyAtMinorCollection &&
((gc_cause != GCCause::_java_lang_system_gc) ||
UseAdaptiveSizePolicyWithSystemGC)) {
// Calculate optimial free space amounts
assert(young_gen->max_size() >
young_gen->from_space()->capacity_in_bytes() +
young_gen->to_space()->capacity_in_bytes(),
"Sizes of space in young gen are out-of-bounds");
size_t young_live = young_gen->used_in_bytes();
size_t eden_live = young_gen->eden_space()->used_in_bytes();
size_t cur_eden = young_gen->eden_space()->capacity_in_bytes();
size_t max_old_gen_size = old_gen->max_gen_size();
size_t max_eden_size = max_young_size -
young_gen->from_space()->capacity_in_bytes() -
young_gen->to_space()->capacity_in_bytes();
// Used for diagnostics
size_policy->clear_generation_free_space_flags();
size_policy->compute_eden_space_size(young_live,
eden_live,
cur_eden,
max_eden_size,
false /* not full gc*/);
size_policy->check_gc_overhead_limit(young_live,
eden_live,
max_old_gen_size,
max_eden_size,
false /* not full gc*/,
gc_cause,
heap->collector_policy());
size_policy->decay_supplemental_growth(false /* not full gc*/);
}
// Resize the young generation at every collection
// even if new sizes have not been calculated. This is
// to allow resizes that may have been inhibited by the
// relative location of the "to" and "from" spaces.
// Resizing the old gen at minor collects can cause increases
// that don't feed back to the generation sizing policy until
// a major collection. Don't resize the old gen here.
heap->resize_young_gen(size_policy->calculated_eden_size_in_bytes(),
size_policy->calculated_survivor_size_in_bytes());
if (PrintAdaptiveSizePolicy) {
gclog_or_tty->print_cr("AdaptiveSizeStop: collection: %d ",
heap->total_collections());
}
}
// Update the structure of the eden. With NUMA-eden CPU hotplugging or offlining can
// cause the change of the heap layout. Make sure eden is reshaped if that's the case.
// Also update() will case adaptive NUMA chunk resizing.
assert(young_gen->eden_space()->is_empty(), "eden space should be empty now");
young_gen->eden_space()->update();
heap->gc_policy_counters()->update_counters();
heap->resize_all_tlabs();
assert(young_gen->to_space()->is_empty(), "to space should be empty now");
}
COMPILER2_PRESENT(DerivedPointerTable::update_pointers());
NOT_PRODUCT(reference_processor()->verify_no_references_recorded());
{
GCTraceTime tm("Prune Scavenge Root Methods", false, false, &_gc_timer);
CodeCache::prune_scavenge_root_nmethods();
}
// Re-verify object start arrays
if (VerifyObjectStartArray &&
VerifyAfterGC) {
old_gen->verify_object_start_array();
}
// Verify all old -> young cards are now precise
if (VerifyRememberedSets) {
// Precise verification will give false positives. Until this is fixed,
// use imprecise verification.
// CardTableExtension::verify_all_young_refs_precise();
CardTableExtension::verify_all_young_refs_imprecise();
}
if (TraceGen0Time) accumulated_time()->stop();
if (PrintGC) {
if (PrintGCDetails) {
// Don't print a GC timestamp here. This is after the GC so
// would be confusing.
young_gen->print_used_change(young_gen_used_before);
}
heap->print_heap_change(prev_used);
}
// Track memory usage and detect low memory
MemoryService::track_memory_usage();
heap->update_counters();
gc_task_manager()->release_idle_workers();
}
if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
Universe::verify(" VerifyAfterGC:");
}
heap->print_heap_after_gc();
heap->trace_heap_after_gc(&_gc_tracer);
_gc_tracer.report_tenuring_threshold(tenuring_threshold());
if (ZapUnusedHeapArea) {
young_gen->eden_space()->check_mangled_unused_area_complete();
young_gen->from_space()->check_mangled_unused_area_complete();
young_gen->to_space()->check_mangled_unused_area_complete();
}
scavenge_exit.update();
if (PrintGCTaskTimeStamps) {
tty->print_cr("VM-Thread " INT64_FORMAT " " INT64_FORMAT " " INT64_FORMAT,
scavenge_entry.ticks(), scavenge_midpoint.ticks(),
scavenge_exit.ticks());
gc_task_manager()->print_task_time_stamps();
}
#ifdef TRACESPINNING
ParallelTaskTerminator::print_termination_counts();
#endif
_gc_timer.register_gc_end();
_gc_tracer.report_gc_end(_gc_timer.gc_end(), _gc_timer.time_partitions());
return !promotion_failure_occurred;
}
//
// ARGUMENT PARSING AND PROGRAM SETUP
//
sysdig_init_res sysdig_init(int argc, char **argv)
{
sysdig_init_res res;
sinsp* inspector = NULL;
vector<string> infiles;
string outfile;
int op;
uint64_t cnt = -1;
bool quiet = false;
bool is_filter_display = false;
bool verbose = false;
bool list_flds = false;
bool print_progress = false;
bool compress = false;
sinsp_evt::param_fmt event_buffer_format = sinsp_evt::PF_NORMAL;
sinsp_filter* display_filter = NULL;
double duration = 1;
captureinfo cinfo;
string output_format;
uint32_t snaplen = 0;
int long_index = 0;
int32_t n_filterargs = 0;
int cflag = 0;
bool jflag = false;
string cname;
vector<summary_table_entry>* summary_table = NULL;
string timefmt = "%evt.time";
// These variables are for the cycle_writer engine
int duration_seconds = 0;
int rollover_mb = 0;
int file_limit = 0;
bool do_cycle = false;
static struct option long_options[] =
{
{"print-ascii", no_argument, 0, 'A' },
{"print-base64", no_argument, 0, 'b' },
#ifdef HAS_CHISELS
{"chisel", required_argument, 0, 'c' },
{"list-chisels", no_argument, &cflag, 1 },
#endif
{"compress", no_argument, 0, 'z' },
{"displayflt", no_argument, 0, 'd' },
{"debug", no_argument, 0, 'D'},
{"fatfile", no_argument, 0, 'F'},
#ifndef DISABLE_CGW
{"seconds", required_argument, 0, 'G' },
#endif
{"help", no_argument, 0, 'h' },
#ifdef HAS_CHISELS
{"chisel-info", required_argument, 0, 'i' },
#endif
#ifndef DISABLE_CGW
{"file-size", required_argument, 0, 'C' },
#endif
{"json", no_argument, 0, 'j' },
{"list", no_argument, 0, 'l' },
{"list-events", no_argument, 0, 'L' },
{"numevents", required_argument, 0, 'n' },
{"progress", required_argument, 0, 'P' },
{"print", required_argument, 0, 'p' },
{"quiet", no_argument, 0, 'q' },
{"readfile", required_argument, 0, 'r' },
{"snaplen", required_argument, 0, 's' },
{"summary", no_argument, 0, 'S' },
{"timetype", required_argument, 0, 't' },
{"verbose", no_argument, 0, 'v' },
{"version", no_argument, 0, 0 },
{"writefile", required_argument, 0, 'w' },
#ifndef DISABLE_CGW
{"limit", required_argument, 0, 'W' },
#endif
{"print-hex", no_argument, 0, 'x'},
{"print-hex-ascii", no_argument, 0, 'X'},
{0, 0, 0, 0}
};
output_format = "*%evt.num <TIME> %evt.cpu %proc.name (%thread.tid) %evt.dir %evt.type %evt.info";
// output_format = DEFAULT_OUTPUT_STR;
try
{
inspector = new sinsp();
#ifdef HAS_CHISELS
add_chisel_dirs(inspector);
#endif
//
// Parse the args
//
while((op = getopt_long(argc, argv,
"Abc:"
#ifndef DISABLE_CGW
"C:"
#endif
"dDF"
#ifndef DISABLE_CGW
"G:"
#endif
"hi:jlLn:Pp:qr:Ss:t:v"
#ifndef DISABLE_CGW
"W:"
#endif
"w:xXz", long_options, &long_index)) != -1)
{
switch(op)
{
case 'A':
if(event_buffer_format != sinsp_evt::PF_NORMAL)
{
fprintf(stderr, "you cannot specify more than one output format\n");
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
}
event_buffer_format = sinsp_evt::PF_EOLS;
break;
case 'b':
if(event_buffer_format != sinsp_evt::PF_NORMAL)
{
fprintf(stderr, "you cannot specify more than one output format\n");
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
}
event_buffer_format = sinsp_evt::PF_BASE64;
break;
case 0:
if(cflag != 1 && cflag != 2)
{
break;
}
if(cflag == 2)
{
cname = optarg;
}
#ifdef HAS_CHISELS
case 'c':
{
if(cflag == 0)
{
string ostr(optarg);
if(ostr.size() >= 1)
{
if(ostr == "l")
{
cflag = 1;
}
}
}
if(cflag == 1)
{
vector<chisel_desc> chlist;
sinsp_chisel::get_chisel_list(&chlist);
list_chisels(&chlist, true);
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
}
sinsp_chisel* ch = new sinsp_chisel(inspector, optarg);
parse_chisel_args(ch, inspector, optind, argc, argv, &n_filterargs);
g_chisels.push_back(ch);
}
#endif
break;
#ifndef DISABLE_CGW
// File-size
case 'C':
rollover_mb = atoi(optarg);
if(rollover_mb <= 0)
{
throw sinsp_exception(string("invalid file size") + optarg);
res.m_res = EXIT_FAILURE;
goto exit;
}
// -C always implicates a cycle
do_cycle = true;
break;
#endif
case 'D':
inspector->set_debug_mode(true);
break;
case 'F':
inspector->set_fatfile_dump_mode(true);
break;
#ifndef DISABLE_CGW
// Number of seconds between roll-over
case 'G':
duration_seconds = atoi(optarg);
if(duration_seconds <= 0)
{
throw sinsp_exception(string("invalid duration") + optarg);
res.m_res = EXIT_FAILURE;
goto exit;
}
break;
#endif
#ifdef HAS_CHISELS
// --chisel-info and -i
case 'i':
{
cname = optarg;
vector<chisel_desc> chlist;
sinsp_chisel::get_chisel_list(&chlist);
for(uint32_t j = 0; j < chlist.size(); j++)
{
if(chlist[j].m_name == cname)
{
print_chisel_info(&chlist[j]);
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
}
}
throw sinsp_exception("chisel " + cname + " not found - use -cl to list them.");
}
break;
#endif
case 'd':
is_filter_display = true;
break;
case 'j':
//
// set the json flag to 1 for now, the data format will depend from the print format parameters
//
jflag = true;
break;
case 'h':
usage();
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
case 'l':
list_flds = true;
break;
case 'L':
list_events(inspector);
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
case 'n':
cnt = atoi(optarg);
if(cnt <= 0)
{
throw sinsp_exception(string("invalid event count ") + optarg);
res.m_res = EXIT_FAILURE;
goto exit;
}
break;
case 'P':
print_progress = true;
break;
case 'p':
if(string(optarg) == "p")
{
//
// -pp shows the default output format, useful if the user wants to tweak it.
//
replace_in_place(output_format, "<TIME>", timefmt);
printf("%s\n", output_format.c_str());
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
}
else
{
output_format = optarg;
}
break;
case 'q':
quiet = true;
break;
case 'r':
infiles.push_back(optarg);
break;
case 'S':
summary_table = new vector<summary_table_entry>;
for(uint32_t j = 0; j < PPM_EVENT_MAX; j++)
{
summary_table->push_back(summary_table_entry(j, false));
}
for(uint32_t j = 0; j < PPM_SC_MAX * 2; j++)
{
summary_table->push_back(summary_table_entry(j, true));
}
break;
case 's':
snaplen = atoi(optarg);
break;
case 't':
{
string tms(optarg);
if(tms == "h")
{
timefmt = "%evt.time";
}
else if(tms == "a")
{
timefmt = "%evt.rawtime.s.%evt.rawtime.ns";
}
else if(tms == "r")
{
timefmt = "%evt.reltime.s.%evt.reltime.ns";
}
else if(tms == "d")
{
timefmt = "%evt.latency.s.%evt.latency.ns";
}
else if(tms == "D")
{
timefmt = "%evt.deltatime.s.%evt.deltatime.ns";
}
else
{
fprintf(stderr, "invalid modifier for flag -t\n");
delete inspector;
return sysdig_init_res(EXIT_FAILURE);
}
}
break;
case 'v':
verbose = true;
break;
case 'w':
outfile = optarg;
quiet = true;
break;
#ifndef DISABLE_CGW
// Number of capture files to cycle through
case 'W':
file_limit = atoi(optarg);
if(file_limit <= 0)
{
throw sinsp_exception(string("invalid file limit") + optarg);
res.m_res = EXIT_FAILURE;
goto exit;
}
break;
#endif
case 'x':
if(event_buffer_format != sinsp_evt::PF_NORMAL)
{
fprintf(stderr, "you cannot specify more than one output format\n");
delete inspector;
return sysdig_init_res(EXIT_FAILURE);
}
event_buffer_format = sinsp_evt::PF_HEX;
break;
case 'X':
if(event_buffer_format != sinsp_evt::PF_NORMAL)
{
fprintf(stderr, "you cannot specify more than one output format\n");
delete inspector;
return sysdig_init_res(EXIT_FAILURE);
}
event_buffer_format = sinsp_evt::PF_HEXASCII;
break;
case 'z':
compress = true;
break;
default:
break;
}
if(string(long_options[long_index].name) == "version")
{
printf("sysdig version %s\n", SYSDIG_VERSION);
delete inspector;
return sysdig_init_res(EXIT_SUCCESS);
}
}
//
// If -j was specified the event_buffer_format must be rewritten to account for it
//
if(jflag)
{
switch (event_buffer_format)
{
case sinsp_evt::PF_NORMAL:
event_buffer_format = sinsp_evt::PF_JSON;
break;
case sinsp_evt::PF_EOLS:
event_buffer_format = sinsp_evt::PF_JSONEOLS;
break;
case sinsp_evt::PF_HEX:
event_buffer_format = sinsp_evt::PF_JSONHEX;
break;
case sinsp_evt::PF_HEXASCII:
event_buffer_format = sinsp_evt::PF_JSONHEXASCII;
break;
case sinsp_evt::PF_BASE64:
event_buffer_format = sinsp_evt::PF_JSONBASE64;
break;
default:
// do nothing
break;
}
}
inspector->set_buffer_format(event_buffer_format);
//
// If -l was specified, print the fields and exit
//
if(list_flds)
{
if(verbose)
{
//
// -ll shows the fields verbosely, i.e. with more information
// like the type
//
list_fields(true);
}
else
{
list_fields(false);
}
res.m_res = EXIT_SUCCESS;
goto exit;
}
string filter;
//
// the filter is at the end of the command line
//
if(optind + n_filterargs < argc)
{
#ifdef HAS_FILTERING
for(int32_t j = optind + n_filterargs; j < argc; j++)
{
filter += argv[j];
if(j < argc)
{
filter += " ";
}
}
if(is_filter_display)
{
display_filter = new sinsp_filter(inspector, filter);
}
#else
fprintf(stderr, "filtering not compiled.\n");
res.m_res = EXIT_FAILURE;
goto exit;
#endif
}
if(signal(SIGINT, signal_callback) == SIG_ERR)
{
fprintf(stderr, "An error occurred while setting SIGINT signal handler.\n");
res.m_res = EXIT_FAILURE;
goto exit;
}
if(signal(SIGTERM, signal_callback) == SIG_ERR)
{
fprintf(stderr, "An error occurred while setting SIGTERM signal handler.\n");
res.m_res = EXIT_FAILURE;
goto exit;
}
//
// Insert the right time format based on the -t flag
//
replace_in_place(output_format, "<TIME>", timefmt);
//
// Create the event formatter
//
sinsp_evt_formatter formatter(inspector, output_format);
for(uint32_t j = 0; j < infiles.size() || infiles.size() == 0; j++)
{
#ifdef HAS_FILTERING
if(filter.size() && !is_filter_display)
{
inspector->set_filter(filter);
}
#endif
//
// Launch the capture
//
bool open_success = true;
if(infiles.size() != 0)
{
initialize_chisels();
//
// We have a file to open
//
inspector->open(infiles[j]);
}
else
{
if(j > 0)
{
break;
}
initialize_chisels();
//
// No file to open, this is a live capture
//
#if defined(HAS_CAPTURE)
if(print_progress)
{
fprintf(stderr, "the -P flag cannot be used with live captures.\n");
res.m_res = EXIT_FAILURE;
goto exit;
}
try
{
inspector->open("");
}
catch(sinsp_exception e)
{
open_success = false;
}
#else
//
// Starting live capture
// If this fails on Windows and OSX, don't try with any driver
//
inspector->open("");
#endif
//
// Starting the live capture failed, try to load the driver with
// modprobe.
//
if(!open_success)
{
open_success = true;
system("modprobe sysdig-probe > /dev/null 2> /dev/null");
inspector->open("");
}
}
if(snaplen != 0)
{
inspector->set_snaplen(snaplen);
}
duration = ((double)clock()) / CLOCKS_PER_SEC;
if(outfile != "")
{
inspector->setup_cycle_writer(outfile, rollover_mb, duration_seconds, file_limit, do_cycle, compress);
inspector->autodump_next_file();
}
//
// Notify the chisels that the capture is starting
//
chisels_on_capture_start();
cinfo = do_inspect(inspector,
cnt,
quiet,
jflag,
print_progress,
display_filter,
summary_table,
&formatter);
duration = ((double)clock()) / CLOCKS_PER_SEC - duration;
scap_stats cstats;
inspector->get_capture_stats(&cstats);
if(verbose)
{
fprintf(stderr, "Driver Events:%" PRIu64 "\nDriver Drops:%" PRIu64 "\n",
cstats.n_evts,
cstats.n_drops);
fprintf(stderr, "Elapsed time: %.3lf, Captured Events: %" PRIu64 ", %.2lf eps\n",
duration,
cinfo.m_nevts,
(double)cinfo.m_nevts / duration);
}
//
// Done. Close the capture.
//
inspector->close();
}
}
catch(sinsp_capture_interrupt_exception&)
{
handle_end_of_file(print_progress);
}
catch(sinsp_exception& e)
{
cerr << e.what() << endl;
handle_end_of_file(print_progress);
res.m_res = EXIT_FAILURE;
}
catch(...)
{
handle_end_of_file(print_progress);
res.m_res = EXIT_FAILURE;
}
exit:
//
// If any of the chisels is requesting another run,
//
for(vector<sinsp_chisel*>::iterator it = g_chisels.begin();
it != g_chisels.end(); ++it)
{
string na;
if((*it)->get_nextrun_args(&na))
{
res.m_next_run_args = sinsp_split(na, ' ');
}
}
//
// If there's a summary table, sort and print it
//
if(summary_table != NULL)
{
print_summary_table(inspector, summary_table, 100);
}
//
// Free all the stuff that was allocated
//
free_chisels();
if(inspector)
{
delete inspector;
}
if(display_filter)
{
delete display_filter;
}
return res;
}
