1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86


base / threading / scoped_thread_priority.cc [blame]

// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/threading/scoped_thread_priority.h"

#include "base/check_op.h"
#include "base/location.h"
#include "base/threading/platform_thread.h"
#include "base/trace_event/base_tracing.h"
#include "build/build_config.h"

namespace base {

ScopedBoostPriority::ScopedBoostPriority(ThreadType target_thread_type) {
  CHECK_LT(target_thread_type, ThreadType::kRealtimeAudio, NotFatalUntil::M133);
  const ThreadType original_thread_type =
      PlatformThread::GetCurrentThreadType();
  const bool should_boost = original_thread_type < target_thread_type &&
                            PlatformThread::CanChangeThreadType(
                                original_thread_type, target_thread_type) &&
                            PlatformThread::CanChangeThreadType(
                                target_thread_type, original_thread_type);
  if (should_boost) {
    original_thread_type_.emplace(original_thread_type);
    PlatformThread::SetCurrentThreadType(target_thread_type);
  }
}

ScopedBoostPriority::~ScopedBoostPriority() {
  if (original_thread_type_.has_value())
    PlatformThread::SetCurrentThreadType(original_thread_type_.value());
}

namespace internal {

ScopedMayLoadLibraryAtBackgroundPriority::
    ScopedMayLoadLibraryAtBackgroundPriority(const Location& from_here,
                                             std::atomic_bool* already_loaded)
#if BUILDFLAG(IS_WIN)
    : already_loaded_(already_loaded)
#endif  // BUILDFLAG(IS_WIN)
{
  TRACE_EVENT_BEGIN(
      "base", "ScopedMayLoadLibraryAtBackgroundPriority",
      [&](perfetto::EventContext ctx) {
        ctx.event()->set_source_location_iid(
            base::trace_event::InternedSourceLocation::Get(&ctx, from_here));
      });

#if BUILDFLAG(IS_WIN)
  if (already_loaded_ && already_loaded_->load(std::memory_order_relaxed))
    return;

  const base::ThreadType thread_type = PlatformThread::GetCurrentThreadType();
  if (thread_type == base::ThreadType::kBackground) {
    original_thread_type_ = thread_type;
    PlatformThread::SetCurrentThreadType(base::ThreadType::kDefault);

    TRACE_EVENT_BEGIN0(
        "base",
        "ScopedMayLoadLibraryAtBackgroundPriority : Priority Increased");
  }
#endif  // BUILDFLAG(IS_WIN)
}

ScopedMayLoadLibraryAtBackgroundPriority::
    ~ScopedMayLoadLibraryAtBackgroundPriority() {
  // Trace events must be closed in reverse order of opening so that they nest
  // correctly.
#if BUILDFLAG(IS_WIN)
  if (original_thread_type_) {
    TRACE_EVENT_END0(
        "base",
        "ScopedMayLoadLibraryAtBackgroundPriority : Priority Increased");
    PlatformThread::SetCurrentThreadType(original_thread_type_.value());
  }

  if (already_loaded_)
    already_loaded_->store(true, std::memory_order_relaxed);
#endif  // BUILDFLAG(IS_WIN)
  TRACE_EVENT_END0("base", "ScopedMayLoadLibraryAtBackgroundPriority");
}

}  // namespace internal
}  // namespace base