g1 region accum_surv_rate_pred

accum_surv_rate_pred()

源码

class G1SurvRateGroup : public CHeapObj<mtGC> {
    double accum_surv_rate_pred(int age) const {
        if ((size_t) age < _stats_arrays_length)
            return _accum_surv_rate_pred[age];
        else {
            double diff = (double) (age - _stats_arrays_length + 1);
            return _accum_surv_rate_pred[_stats_arrays_length - 1] + diff * _last_pred;
        }
    }
};

double G1Policy::predict_eden_copy_time_ms(uint count, size_t* bytes_to_copy) const {
    size_t const expected_bytes = _eden_surv_rate_group->accum_surv_rate_pred(count) * HeapRegion::GrainBytes;
    if (bytes_to_copy != NULL) {
        *bytes_to_copy = expected_bytes;
    }
}

_eden_surv_rate_group 赋值

G1Policy::G1Policy(STWGCTimer* gc_timer) :
    _eden_surv_rate_group(new G1SurvRateGroup()) {
}

_accum_surv_rate_pred 赋值

class G1SurvRateGroup : public CHeapObj<mtGC> {
    size_t  _stats_arrays_length;
    double* _accum_surv_rate_pred;
    
};
void G1SurvRateGroup::finalize_predictions(const G1Predictions& predictor) {
    double accum = 0.0;
    double pred = 0.0;
    for (size_t i = 0; i < _stats_arrays_length; ++i) {
        pred = predictor.predict_in_unit_interval(_surv_rate_predictors[i]);
        accum += pred;
        _accum_surv_rate_pred[i] = accum;
    }
}

void G1SurvRateGroup::all_surviving_words_recorded(const G1Predictions& predictor, bool update_predictors) {
    finalize_predictions(predictor);
}

class G1Policy: public CHeapObj<mtGC> {
    void cset_regions_freed() {
        _eden_surv_rate_group->all_surviving_words_recorded(predictor(), update);
        _survivor_surv_rate_group->all_surviving_words_recorded(predictor(), update);
    }
};

class FreeCSetStats {
    void report(G1CollectedHeap* g1h, G1EvacuationInfo* evacuation_info) {
        G1Policy *policy = g1h->policy();
        policy->cset_regions_freed();
    }
};

void G1PostEvacuateCollectionSetCleanupTask2::FreeCollectionSetTask::report_statistics() {
    total_stats.report(_g1h, _evacuation_info);
}

G1PostEvacuateCollectionSetCleanupTask2::FreeCollectionSetTask::~FreeCollectionSetTask() {
    report_statistics();
}

void G1CollectedHeap::post_evacuate_cleanup_2(PreservedMarksSet *preserved_marks,
                                              G1RedirtyCardsQueueSet *rdcqs,
                                              G1EvacuationInfo *evacuation_info,
                                              const size_t *surviving_young_words) {
    {
        G1PostEvacuateCollectionSetCleanupTask2 cl(preserved_marks, rdcqs, evacuation_info, surviving_young_words);
        run_batch_task(&cl);
    }
}

void G1CollectedHeap::post_evacuate_collection_set(G1EvacuationInfo& evacuation_info,
                                                   G1RedirtyCardsQueueSet* rdcqs,
                                                   G1ParScanThreadStateSet* per_thread_states) {
    post_evacuate_cleanup_2(&_preserved_marks_set, rdcqs, &evacuation_info, per_thread_states->surviving_young_words());
}

void G1CollectedHeap::do_collection_pause_at_safepoint_helper(double target_pause_time_ms) {
    post_evacuate_collection_set(evacuation_info, &rdcqs, &per_thread_states);
}

predict_in_unit_interval 内容

class G1Predictions {
    double stddev_estimate(TruncatedSeq const* seq) const {
        double estimate = seq->dsd();
        int const samples = seq->num();
        if (samples < 5) {
            estimate = MAX2(seq->davg() * (5 - samples) / 2.0, estimate);
        }
        return estimate;
    }
    double predict(TruncatedSeq const* seq) const {
        return seq->davg() + _sigma * stddev_estimate(seq);
    }
    double predict_in_unit_interval(TruncatedSeq const* seq) const {
        return clamp(predict(seq), 0.0, 1.0);
    }
};

template<typename T>
inline T clamp(T value, T min, T max) {
  return MIN2(MAX2(value, min), max);
}