From 05e428dacb0b4877960e3b1c0d50cb9c90f378d5 Mon Sep 17 00:00:00 2001 From: Nicolas Geoffray Date: Sun, 9 Jun 2024 14:15:44 +0000 Subject: Reland "Rewrite how we identify hot methods." This reverts commit e5d59342bcfdb7f6d2e7d7b4a4ce8dd97ca39091. With this CL, startup methods which do not reach the JIT threshold will just be marked as startup. The compiler driver now decides whether they should be compiled. Reason for revert: Move the decision of compiling startup methods in the compiler driver. Change-Id: Iba8ac7f092e1ce0f412a579a93da57e82fdea4a6 --- cmdline/cmdline_parser_test.cc | 14 +++++----- cmdline/cmdline_types.h | 6 ++--- compiler/jit/jit_compiler.cc | 3 ++- compiler/optimizing/nodes.h | 2 ++ compiler/optimizing/optimizing_compiler.cc | 6 +++++ dex2oat/driver/compiler_driver.cc | 9 +++++-- runtime/art_method-inl.h | 7 ----- runtime/art_method.h | 1 - runtime/interpreter/mterp/nterp.cc | 3 +++ runtime/jit/jit_code_cache.cc | 33 ++---------------------- runtime/jit/jit_code_cache.h | 1 - runtime/jit/profile_saver.cc | 32 +++-------------------- runtime/jit/profile_saver_options.h | 18 ------------- runtime/jit/profiling_info.h | 8 ------ test/2230-profile-save-hotness/run.py | 5 ++-- test/2230-profile-save-hotness/src-art/Main.java | 4 +-- 16 files changed, 39 insertions(+), 113 deletions(-) diff --git a/cmdline/cmdline_parser_test.cc b/cmdline/cmdline_parser_test.cc index 5d6ba4446e..e586dd4292 100644 --- a/cmdline/cmdline_parser_test.cc +++ b/cmdline/cmdline_parser_test.cc @@ -38,7 +38,6 @@ namespace art { return lhs.enabled_ == rhs.enabled_ && lhs.min_save_period_ms_ == rhs.min_save_period_ms_ && lhs.save_resolved_classes_delay_ms_ == rhs.save_resolved_classes_delay_ms_ && - lhs.hot_startup_method_samples_ == rhs.hot_startup_method_samples_ && lhs.min_methods_to_save_ == rhs.min_methods_to_save_ && lhs.min_classes_to_save_ == rhs.min_classes_to_save_ && lhs.min_notification_before_wake_ == rhs.min_notification_before_wake_ && @@ -490,19 +489,18 @@ TEST_F(CmdlineParserTest, TestJitOptions) { * -Xps-* */ TEST_F(CmdlineParserTest, ProfileSaverOptions) { - ProfileSaverOptions opt = ProfileSaverOptions(true, 1, 2, 3, 4, 5, 6, 7, 8, 9, "abc", true); + ProfileSaverOptions opt = ProfileSaverOptions(true, 1, 2, 3, 4, 5, 6, 7, 8, "abc", true); EXPECT_SINGLE_PARSE_VALUE(opt, "-Xjitsaveprofilinginfo " "-Xps-min-save-period-ms:1 " "-Xps-min-first-save-ms:2 " "-Xps-save-resolved-classes-delay-ms:3 " - "-Xps-hot-startup-method-samples:4 " - "-Xps-min-methods-to-save:5 " - "-Xps-min-classes-to-save:6 " - "-Xps-min-notification-before-wake:7 " - "-Xps-max-notification-before-wake:8 " - "-Xps-inline-cache-threshold:9 " + "-Xps-min-methods-to-save:4 " + "-Xps-min-classes-to-save:5 " + "-Xps-min-notification-before-wake:6 " + "-Xps-max-notification-before-wake:7 " + "-Xps-inline-cache-threshold:8 " "-Xps-profile-path:abc " "-Xps-profile-boot-class-path", M::ProfileSaverOpts); diff --git a/cmdline/cmdline_types.h b/cmdline/cmdline_types.h index 7cacfde12a..34c1b0fc97 100644 --- a/cmdline/cmdline_types.h +++ b/cmdline/cmdline_types.h @@ -832,10 +832,8 @@ struct CmdlineType : CmdlineTypeParser type_parser.Parse(suffix)); } if (android::base::StartsWith(option, "hot-startup-method-samples:")) { - CmdlineType type_parser; - return ParseInto(existing, - &ProfileSaverOptions::hot_startup_method_samples_, - type_parser.Parse(suffix)); + LOG(WARNING) << "-Xps-hot-startup-method-samples option is deprecated"; + return Result::SuccessNoValue(); } if (android::base::StartsWith(option, "min-methods-to-save:")) { CmdlineType type_parser; diff --git a/compiler/jit/jit_compiler.cc b/compiler/jit/jit_compiler.cc index 051368cc8a..4b2f8d2e14 100644 --- a/compiler/jit/jit_compiler.cc +++ b/compiler/jit/jit_compiler.cc @@ -178,7 +178,8 @@ bool JitCompiler::CompileMethod( Thread* self, JitMemoryRegion* region, ArtMethod* method, CompilationKind compilation_kind) { SCOPED_TRACE << "JIT compiling " << method->PrettyMethod() - << " (kind=" << compilation_kind << ")"; + << " (kind=" << compilation_kind << ")" + << " from " << method->GetDexFile()->GetLocation(); DCHECK(!method->IsProxyMethod()); DCHECK(method->GetDeclaringClass()->IsResolved()); diff --git a/compiler/optimizing/nodes.h b/compiler/optimizing/nodes.h index 33ffc07ba8..89369f59f1 100644 --- a/compiler/optimizing/nodes.h +++ b/compiler/optimizing/nodes.h @@ -143,6 +143,8 @@ enum GraphAnalysisResult { kAnalysisSuccess, }; +std::ostream& operator<<(std::ostream& os, GraphAnalysisResult ga); + template static inline typename std::make_unsigned::type MakeUnsigned(T x) { return static_cast::type>(x); diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc index 45d534a9ec..3f73459a00 100644 --- a/compiler/optimizing/optimizing_compiler.cc +++ b/compiler/optimizing/optimizing_compiler.cc @@ -30,6 +30,7 @@ #include "base/macros.h" #include "base/mutex.h" #include "base/scoped_arena_allocator.h" +#include "base/systrace.h" #include "base/timing_logger.h" #include "builder.h" #include "code_generator.h" @@ -781,6 +782,7 @@ CodeGenerator* OptimizingCompiler::TryCompile(ArenaAllocator* allocator, } if (Compiler::IsPathologicalCase(*code_item, method_idx, dex_file)) { + SCOPED_TRACE << "Not compiling because of pathological case"; MaybeRecordStat(compilation_stats_.get(), MethodCompilationStat::kNotCompiledPathological); return nullptr; } @@ -791,6 +793,7 @@ CodeGenerator* OptimizingCompiler::TryCompile(ArenaAllocator* allocator, if ((compiler_options.GetCompilerFilter() == CompilerFilter::kSpace) && (CodeItemInstructionAccessor(dex_file, code_item).InsnsSizeInCodeUnits() > kSpaceFilterOptimizingThreshold)) { + SCOPED_TRACE << "Not compiling because of space filter"; MaybeRecordStat(compilation_stats_.get(), MethodCompilationStat::kNotCompiledSpaceFilter); return nullptr; } @@ -865,6 +868,7 @@ CodeGenerator* OptimizingCompiler::TryCompile(ArenaAllocator* allocator, compilation_stats_.get()); GraphAnalysisResult result = builder.BuildGraph(); if (result != kAnalysisSuccess) { + SCOPED_TRACE << "Not compiling because of " << result; switch (result) { case kAnalysisSkipped: { MaybeRecordStat(compilation_stats_.get(), @@ -927,6 +931,7 @@ CodeGenerator* OptimizingCompiler::TryCompile(ArenaAllocator* allocator, // However, we may have run out of memory trying to create it, so in this // case just abort the compilation. if (graph->GetProfilingInfo() == nullptr) { + SCOPED_TRACE << "Not compiling because of out of memory"; MaybeRecordStat(compilation_stats_.get(), MethodCompilationStat::kJitOutOfMemoryForCommit); return nullptr; } @@ -938,6 +943,7 @@ CodeGenerator* OptimizingCompiler::TryCompile(ArenaAllocator* allocator, compilation_stats_.get()); if (UNLIKELY(codegen->GetFrameSize() > codegen->GetMaximumFrameSize())) { + SCOPED_TRACE << "Not compiling because of stack frame too large"; LOG(WARNING) << "Stack frame size is " << codegen->GetFrameSize() << " which is larger than the maximum of " << codegen->GetMaximumFrameSize() << " bytes. Method: " << graph->PrettyMethod(); diff --git a/dex2oat/driver/compiler_driver.cc b/dex2oat/driver/compiler_driver.cc index c696191491..9eb3e95b59 100644 --- a/dex2oat/driver/compiler_driver.cc +++ b/dex2oat/driver/compiler_driver.cc @@ -434,15 +434,20 @@ static bool ShouldCompileBasedOnProfile(const CompilerOptions& compiler_options, compiler_options.GetProfileCompilationInfo(); DCHECK(profile_compilation_info != nullptr); - // Compile only hot methods, it is the profile saver's job to decide - // what startup methods to mark as hot. bool result = profile_compilation_info->IsHotMethod(profile_index, method_ref.index); + // On non-low RAM devices, compile startup methods to potentially speed up + // startup. + if (!result && Runtime::Current()->GetHeap()->IsLowMemoryMode()) { + result = profile_compilation_info->IsStartupMethod(profile_index, method_ref.index); + } + if (kDebugProfileGuidedCompilation) { LOG(INFO) << "[ProfileGuidedCompilation] " << (result ? "Compiled" : "Skipped") << " method:" << method_ref.PrettyMethod(true); } + return result; } } diff --git a/runtime/art_method-inl.h b/runtime/art_method-inl.h index b2711d968a..d87040ab49 100644 --- a/runtime/art_method-inl.h +++ b/runtime/art_method-inl.h @@ -777,13 +777,6 @@ inline bool ArtMethod::CounterIsHot() { return hotness_count_ == 0; } -inline bool ArtMethod::CounterHasReached(uint16_t samples, uint16_t threshold) { - DCHECK(!IsAbstract()); - DCHECK_EQ(threshold, Runtime::Current()->GetJITOptions()->GetWarmupThreshold()); - DCHECK_LE(samples, threshold); - return hotness_count_ <= (threshold - samples); -} - inline uint16_t ArtMethod::GetCounter() { DCHECK(!IsAbstract()); return hotness_count_; diff --git a/runtime/art_method.h b/runtime/art_method.h index a23969aa73..0a6cda65fd 100644 --- a/runtime/art_method.h +++ b/runtime/art_method.h @@ -1011,7 +1011,6 @@ class EXPORT ArtMethod final { ALWAYS_INLINE void UpdateCounter(int32_t new_samples); ALWAYS_INLINE void SetHotCounter(); ALWAYS_INLINE bool CounterIsHot(); - ALWAYS_INLINE bool CounterHasReached(uint16_t samples, uint16_t threshold); ALWAYS_INLINE uint16_t GetCounter(); ALWAYS_INLINE bool CounterHasChanged(uint16_t threshold); diff --git a/runtime/interpreter/mterp/nterp.cc b/runtime/interpreter/mterp/nterp.cc index d8ce2bcaed..64f04d6fde 100644 --- a/runtime/interpreter/mterp/nterp.cc +++ b/runtime/interpreter/mterp/nterp.cc @@ -693,7 +693,10 @@ extern "C" jit::OsrData* NterpHotMethod(ArtMethod* method, uint16_t* dex_pc_ptr, DCHECK_EQ(Thread::Current()->GetSharedMethodHotness(), 0u); Thread::Current()->ResetSharedMethodHotness(); } else { + // Move the counter to the initial threshold in case we have to re-JIT it. method->ResetCounter(runtime->GetJITOptions()->GetWarmupThreshold()); + // Mark the method as warm for the profile saver. + method->SetPreviouslyWarm(); } jit::Jit* jit = runtime->GetJit(); if (jit != nullptr && jit->UseJitCompilation()) { diff --git a/runtime/jit/jit_code_cache.cc b/runtime/jit/jit_code_cache.cc index 89be345875..4b69dc5c01 100644 --- a/runtime/jit/jit_code_cache.cc +++ b/runtime/jit/jit_code_cache.cc @@ -649,17 +649,6 @@ void JitCodeCache::CopyInlineCacheInto( } } -static void ClearMethodCounter(ArtMethod* method, bool was_warm) - REQUIRES_SHARED(Locks::mutator_lock_) { - if (was_warm) { - method->SetPreviouslyWarm(); - } - method->ResetCounter(Runtime::Current()->GetJITOptions()->GetWarmupThreshold()); - // We add one sample so that the profile knows that the method was executed at least once. - // This is required for layout purposes. - method->UpdateCounter(/* new_samples= */ 1); -} - bool JitCodeCache::Commit(Thread* self, JitMemoryRegion* region, ArtMethod* method, @@ -727,10 +716,9 @@ bool JitCodeCache::Commit(Thread* self, bool single_impl_still_valid = true; for (ArtMethod* single_impl : cha_single_implementation_list) { if (!single_impl->HasSingleImplementation()) { - // Simply discard the compiled code. Clear the counter so that it may be recompiled later. + // Simply discard the compiled code. // Hopefully the class hierarchy will be more stable when compilation is retried. single_impl_still_valid = false; - ClearMethodCounter(method, /*was_warm=*/ false); break; } } @@ -825,7 +813,6 @@ bool JitCodeCache::RemoveMethod(ArtMethod* method, bool release_memory) { return false; } - ClearMethodCounter(method, /* was_warm= */ false); Runtime::Current()->GetInstrumentation()->InitializeMethodsCode(method, /*aot_code=*/ nullptr); VLOG(jit) << "JIT removed (osr=" << std::boolalpha << osr << std::noboolalpha << ") " @@ -1247,15 +1234,6 @@ void JitCodeCache::MaybeUpdateInlineCache(ArtMethod* method, info->AddInvokeInfo(dex_pc, cls.Ptr()); } -void JitCodeCache::ResetHotnessCounter(ArtMethod* method, Thread* self) { - ScopedDebugDisallowReadBarriers sddrb(self); - MutexLock mu(self, *Locks::jit_lock_); - auto it = profiling_infos_.find(method); - DCHECK(it != profiling_infos_.end()); - it->second->ResetCounter(); -} - - void JitCodeCache::DoCollection(Thread* self) { ScopedTrace trace(__FUNCTION__); @@ -1606,8 +1584,6 @@ bool JitCodeCache::NotifyCompilationOf(ArtMethod* method, VLOG(jit) << "Not compiling " << method->PrettyMethod() << " because it has the resolution stub"; - // Give it a new chance to be hot. - ClearMethodCounter(method, /*was_warm=*/ false); return false; } } @@ -1708,15 +1684,12 @@ void JitCodeCache::InvalidateAllCompiledCode() { OatQuickMethodHeader::FromCodePointer(data.GetCode()); for (ArtMethod* method : data.GetMethods()) { if (method->GetEntryPointFromQuickCompiledCode() == method_header->GetEntryPoint()) { - ClearMethodCounter(method, /*was_warm=*/true); instr->InitializeMethodsCode(method, /*aot_code=*/ nullptr); } } } for (const auto& entry : method_code_map_) { ArtMethod* meth = entry.second; - // We were compiled, so we must be warm. - ClearMethodCounter(meth, /*was_warm=*/true); if (UNLIKELY(meth->IsObsolete())) { linker->SetEntryPointsForObsoleteMethod(meth); } else { @@ -1746,10 +1719,8 @@ void JitCodeCache::InvalidateCompiledCodeFor(ArtMethod* method, // Clear the method counter if we are running jitted code since we might want to jit this again in // the future. if (method_entrypoint == header->GetEntryPoint()) { - // The entrypoint is the one to invalidate, so we just update it to the interpreter entry point - // and clear the counter to get the method Jitted again. + // The entrypoint is the one to invalidate, so we just update it to the interpreter entry point. Runtime::Current()->GetInstrumentation()->InitializeMethodsCode(method, /*aot_code=*/ nullptr); - ClearMethodCounter(method, /*was_warm=*/ true); } else { Thread* self = Thread::Current(); ScopedDebugDisallowReadBarriers sddrb(self); diff --git a/runtime/jit/jit_code_cache.h b/runtime/jit/jit_code_cache.h index 7de29d4024..3dd57121ca 100644 --- a/runtime/jit/jit_code_cache.h +++ b/runtime/jit/jit_code_cache.h @@ -414,7 +414,6 @@ class JitCodeCache { } ProfilingInfo* GetProfilingInfo(ArtMethod* method, Thread* self); - void ResetHotnessCounter(ArtMethod* method, Thread* self); void MaybeUpdateInlineCache(ArtMethod* method, uint32_t dex_pc, ObjPtr cls, diff --git a/runtime/jit/profile_saver.cc b/runtime/jit/profile_saver.cc index abf01f5498..3506faaa7f 100644 --- a/runtime/jit/profile_saver.cc +++ b/runtime/jit/profile_saver.cc @@ -335,7 +335,6 @@ class ProfileSaver::GetClassesAndMethodsHelper { REQUIRES_SHARED(Locks::mutator_lock_) : startup_(startup), profile_boot_class_path_(options.GetProfileBootClassPath()), - hot_method_sample_threshold_(CalculateHotMethodSampleThreshold(startup, options)), extra_flags_(GetExtraMethodHotnessFlags(options)), annotation_(annotation), arena_stack_(Runtime::Current()->GetArenaPool()), @@ -358,10 +357,6 @@ class ProfileSaver::GetClassesAndMethodsHelper { void CollectClasses(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_); void UpdateProfile(const std::set& locations, ProfileCompilationInfo* profile_info); - uint32_t GetHotMethodSampleThreshold() const { - return hot_method_sample_threshold_; - } - size_t GetNumberOfHotMethods() const { return number_of_hot_methods_; } @@ -409,19 +404,6 @@ class ProfileSaver::GetClassesAndMethodsHelper { using DexFileRecordsMap = ScopedArenaHashMap; - static uint32_t CalculateHotMethodSampleThreshold(bool startup, - const ProfileSaverOptions& options) { - Runtime* runtime = Runtime::Current(); - if (startup) { - const bool is_low_ram = runtime->GetHeap()->IsLowMemoryMode(); - return options.GetHotStartupMethodSamples(is_low_ram); - } else if (runtime->GetJit() != nullptr) { - return runtime->GetJit()->WarmMethodThreshold(); - } else { - return std::numeric_limits::max(); - } - } - ALWAYS_INLINE static bool ShouldCollectClasses(bool startup) { // We only record classes for the startup case. This may change in the future. return startup; @@ -434,7 +416,6 @@ class ProfileSaver::GetClassesAndMethodsHelper { const bool startup_; const bool profile_boot_class_path_; - const uint32_t hot_method_sample_threshold_; const uint32_t extra_flags_; const ProfileCompilationInfo::ProfileSampleAnnotation annotation_; ArenaStack arena_stack_; @@ -609,7 +590,6 @@ void ProfileSaver::GetClassesAndMethodsHelper::UpdateProfile(const std::setGetJITOptions()->GetWarmupThreshold(); auto get_method_flags = [&](ArtMethod& method) { - // Mark methods as hot if they have more than hot_method_sample_threshold - // samples. This means they will get compiled by the compiler driver. - if (method.PreviouslyWarm() || - method.CounterHasReached(hot_method_sample_threshold, initial_value)) { + // Mark methods as hot if they are marked as such (warm for the runtime + // means hot for the profile). + if (method.PreviouslyWarm()) { ++number_of_hot_methods; return enum_cast(base_flags | Hotness::kFlagHot); } else if (method.CounterHasChanged(initial_value)) { @@ -750,7 +729,6 @@ void ProfileSaver::FetchAndCacheResolvedClassesAndMethods(bool startup) { profiler_pthread = profiler_pthread_; } - uint32_t hot_method_sample_threshold = 0u; size_t number_of_hot_methods = 0u; size_t number_of_sampled_methods = 0u; { @@ -765,7 +743,6 @@ void ProfileSaver::FetchAndCacheResolvedClassesAndMethods(bool startup) { ScopedObjectAccess soa(self); GetClassesAndMethodsHelper helper(startup, options_, GetProfileSampleAnnotation()); - hot_method_sample_threshold = helper.GetHotMethodSampleThreshold(); helper.CollectClasses(self); // Release the mutator lock. We shall need to re-acquire the lock for a moment to @@ -800,8 +777,7 @@ void ProfileSaver::FetchAndCacheResolvedClassesAndMethods(bool startup) { } VLOG(profiler) << "Profile saver recorded " << number_of_hot_methods << " hot methods and " << number_of_sampled_methods - << " sampled methods with threshold " << hot_method_sample_threshold - << " in " << PrettyDuration(NanoTime() - start_time); + << " sampled methods in " << PrettyDuration(NanoTime() - start_time); } bool ProfileSaver::ProcessProfilingInfo( diff --git a/runtime/jit/profile_saver_options.h b/runtime/jit/profile_saver_options.h index f6d928ff6b..ed2f00f48f 100644 --- a/runtime/jit/profile_saver_options.h +++ b/runtime/jit/profile_saver_options.h @@ -26,14 +26,10 @@ struct ProfileSaverOptions { // period is not configured. static constexpr uint32_t kMinFirstSaveMsNotSet = 0; static constexpr uint32_t kSaveResolvedClassesDelayMs = 5 * 1000; // 5 seconds - // Minimum number of JIT samples during launch to mark a method as hot in the profile. - static constexpr uint32_t kHotStartupMethodSamples = 1; - static constexpr uint32_t kHotStartupMethodSamplesLowRam = 256; static constexpr uint32_t kMinMethodsToSave = 10; static constexpr uint32_t kMinClassesToSave = 10; static constexpr uint32_t kMinNotificationBeforeWake = 10; static constexpr uint32_t kMaxNotificationBeforeWake = 50; - static constexpr uint32_t kHotStartupMethodSamplesNotSet = std::numeric_limits::max(); static constexpr uint16_t kInlineCacheThreshold = 4000; ProfileSaverOptions() : @@ -41,7 +37,6 @@ struct ProfileSaverOptions { min_save_period_ms_(kMinSavePeriodMs), min_first_save_ms_(kMinFirstSaveMsNotSet), save_resolved_classes_delay_ms_(kSaveResolvedClassesDelayMs), - hot_startup_method_samples_(kHotStartupMethodSamplesNotSet), min_methods_to_save_(kMinMethodsToSave), min_classes_to_save_(kMinClassesToSave), min_notification_before_wake_(kMinNotificationBeforeWake), @@ -57,7 +52,6 @@ struct ProfileSaverOptions { uint32_t min_save_period_ms, uint32_t min_first_save_ms, uint32_t save_resolved_classes_delay_ms, - uint32_t hot_startup_method_samples, uint32_t min_methods_to_save, uint32_t min_classes_to_save, uint32_t min_notification_before_wake, @@ -71,7 +65,6 @@ struct ProfileSaverOptions { min_save_period_ms_(min_save_period_ms), min_first_save_ms_(min_first_save_ms), save_resolved_classes_delay_ms_(save_resolved_classes_delay_ms), - hot_startup_method_samples_(hot_startup_method_samples), min_methods_to_save_(min_methods_to_save), min_classes_to_save_(min_classes_to_save), min_notification_before_wake_(min_notification_before_wake), @@ -98,13 +91,6 @@ struct ProfileSaverOptions { uint32_t GetSaveResolvedClassesDelayMs() const { return save_resolved_classes_delay_ms_; } - uint32_t GetHotStartupMethodSamples(bool is_low_ram) const { - uint32_t ret = hot_startup_method_samples_; - if (ret == kHotStartupMethodSamplesNotSet) { - ret = is_low_ram ? kHotStartupMethodSamplesLowRam : kHotStartupMethodSamples; - } - return ret; - } uint32_t GetMinMethodsToSave() const { return min_methods_to_save_; } @@ -141,7 +127,6 @@ struct ProfileSaverOptions { << ", min_save_period_ms_" << pso.min_save_period_ms_ << ", min_first_save_ms_" << pso.min_first_save_ms_ << ", save_resolved_classes_delay_ms_" << pso.save_resolved_classes_delay_ms_ - << ", hot_startup_method_samples_" << pso.hot_startup_method_samples_ << ", min_methods_to_save_" << pso.min_methods_to_save_ << ", min_classes_to_save_" << pso.min_classes_to_save_ << ", min_notification_before_wake_" << pso.min_notification_before_wake_ @@ -157,9 +142,6 @@ struct ProfileSaverOptions { uint32_t min_save_period_ms_; uint32_t min_first_save_ms_; uint32_t save_resolved_classes_delay_ms_; - // Do not access hot_startup_method_samples_ directly for reading since it may be set to the - // placeholder default. - uint32_t hot_startup_method_samples_; uint32_t min_methods_to_save_; uint32_t min_classes_to_save_; uint32_t min_notification_before_wake_; diff --git a/runtime/jit/profiling_info.h b/runtime/jit/profiling_info.h index ae59d0ade1..a32b712b0c 100644 --- a/runtime/jit/profiling_info.h +++ b/runtime/jit/profiling_info.h @@ -171,14 +171,6 @@ class ProfilingInfo { return MemberOffset(OFFSETOF_MEMBER(ProfilingInfo, baseline_hotness_count_)); } - void ResetCounter() { - baseline_hotness_count_ = GetOptimizeThreshold(); - } - - bool CounterHasChanged() const { - return baseline_hotness_count_ != GetOptimizeThreshold(); - } - uint16_t GetBaselineHotnessCount() const { return baseline_hotness_count_; } diff --git a/test/2230-profile-save-hotness/run.py b/test/2230-profile-save-hotness/run.py index 526b841b87..e2f4473b86 100644 --- a/test/2230-profile-save-hotness/run.py +++ b/test/2230-profile-save-hotness/run.py @@ -16,10 +16,11 @@ def run(ctx, args): ctx.default_run( args, + # Profiling is only done on interpreted and JITted code. Xcompiler_option=[ - "--count-hotness-in-compiled-code", "--compiler-filter=speed" + "--compiler-filter=verify" ], runtime_option=[ - "-Xps-profile-aot-code", "-Xjitsaveprofilinginfo", "-Xusejit:true" + "-Xjitsaveprofilinginfo", "-Xusejit:true" ], ) diff --git a/test/2230-profile-save-hotness/src-art/Main.java b/test/2230-profile-save-hotness/src-art/Main.java index c9132e6e7d..06e89b2ade 100644 --- a/test/2230-profile-save-hotness/src-art/Main.java +++ b/test/2230-profile-save-hotness/src-art/Main.java @@ -47,7 +47,7 @@ public class Main { new String[] {codePath}, VMRuntime.CODE_PATH_TYPE_PRIMARY_APK); - // Test that the profile saves an app method with a profiling info. + // Test that the profile saves an app method that gets JITted. $noinline$hotnessCountWithLoop(100000); ensureProfileProcessing(); Method appMethod = Main.class.getDeclaredMethod(methodName); @@ -72,7 +72,7 @@ public class Main { } } - // Checks if the profiles saver has the method as hot/warm. + // Checks if the profile saver has the method as hot/warm. public static native boolean presentInProfile(String profile, Method method); // Ensures the profile saver does its usual processing. public static native void ensureProfileProcessing(); -- cgit v1.2.3-59-g8ed1b