net/base/prioritized_dispatcher.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/base/prioritized_dispatcher.h"
   6
   7 #include "base/logging.h"
   8
   9 namespace net {
  10
  11 PrioritizedDispatcher::Limits::Limits(Priority num_priorities,
  12                                       size_t total_jobs)
  13     : total_jobs(total_jobs), reserved_slots(num_priorities) {}
  14
  15 PrioritizedDispatcher::Limits::~Limits() {}
  16
  17 PrioritizedDispatcher::PrioritizedDispatcher(const Limits& limits)
  18     : queue_(limits.reserved_slots.size()),
  19       max_running_jobs_(limits.reserved_slots.size()),
  20       num_running_jobs_(0) {
  21   size_t total = 0;
  22   for (size_t i = 0; i < limits.reserved_slots.size(); ++i) {
  23     total += limits.reserved_slots[i];
  24     max_running_jobs_[i] = total;
  25   }
  26   // Unreserved slots are available for all priorities.
  27   DCHECK_LE(total, limits.total_jobs) << "sum(reserved_slots) <= total_jobs";
  28   size_t spare = limits.total_jobs - total;
  29   for (size_t i = limits.reserved_slots.size(); i > 0; --i) {
  30     max_running_jobs_[i - 1] += spare;
  31   }
  32 }
  33
  34 PrioritizedDispatcher::~PrioritizedDispatcher() {}
  35
  36 PrioritizedDispatcher::Handle PrioritizedDispatcher::Add(
  37     Job* job, Priority priority) {
  38   DCHECK(job);
  39   DCHECK_LT(priority, num_priorities());
  40   if (num_running_jobs_ < max_running_jobs_[priority]) {
  41     ++num_running_jobs_;
  42     job->Start();
  43     return Handle();
  44   }
  45   return queue_.Insert(job, priority);
  46 }
  47
  48 void PrioritizedDispatcher::Cancel(const Handle& handle) {
  49   queue_.Erase(handle);
  50 }
  51
  52 PrioritizedDispatcher::Job* PrioritizedDispatcher::EvictOldestLowest() {
  53   Handle handle = queue_.FirstMin();
  54   if (handle.is_null())
  55     return NULL;
  56   Job* job = handle.value();
  57   Cancel(handle);
  58   return job;
  59 }
  60
  61 PrioritizedDispatcher::Handle PrioritizedDispatcher::ChangePriority(
  62     const Handle& handle, Priority priority) {
  63   DCHECK(!handle.is_null());
  64   DCHECK_LT(priority, num_priorities());
  65   DCHECK_GE(num_running_jobs_, max_running_jobs_[handle.priority()]) <<
  66       "Job should not be in queue when limits permit it to start.";
  67
  68   if (handle.priority() == priority)
  69     return handle;
  70
  71   if (MaybeDispatchJob(handle, priority))
  72     return Handle();
  73   Job* job = handle.value();
  74   queue_.Erase(handle);
  75   return queue_.Insert(job, priority);
  76 }
  77
  78 void PrioritizedDispatcher::OnJobFinished() {
  79   DCHECK_GT(num_running_jobs_, 0u);
  80   --num_running_jobs_;
  81   Handle handle = queue_.FirstMax();
  82   if (handle.is_null()) {
  83     DCHECK_EQ(0u, queue_.size());
  84     return;
  85   }
  86   MaybeDispatchJob(handle, handle.priority());
  87 }
  88
  89 bool PrioritizedDispatcher::MaybeDispatchJob(const Handle& handle,
  90                                              Priority job_priority) {
  91   DCHECK_LT(job_priority, num_priorities());
  92   if (num_running_jobs_ >= max_running_jobs_[job_priority])
  93     return false;
  94   Job* job = handle.value();
  95   queue_.Erase(handle);
  96   ++num_running_jobs_;
  97   job->Start();
  98   return true;
  99 }
 100
 101 }  // namespace net