Home | History | Annotate | Download | only in client 
      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 // This file contains the implementation of the command buffer helper class.
      6 
      7 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
      8 
      9 #include "base/logging.h"
     10 #include "base/time/time.h"
     11 #include "gpu/command_buffer/common/command_buffer.h"
     12 #include "gpu/command_buffer/common/trace_event.h"
     13 
     14 namespace gpu {
     15 
     16 CommandBufferHelper::CommandBufferHelper(CommandBuffer* command_buffer)
     17     : command_buffer_(command_buffer),
     18       ring_buffer_id_(-1),
     19       ring_buffer_size_(0),
     20       entries_(NULL),
     21       total_entry_count_(0),
     22       immediate_entry_count_(0),
     23       token_(0),
     24       put_(0),
     25       last_put_sent_(0),
     26 #if defined(CMD_HELPER_PERIODIC_FLUSH_CHECK)
     27       commands_issued_(0),
     28 #endif
     29       usable_(true),
     30       context_lost_(false),
     31       flush_automatically_(true),
     32       flush_generation_(0) {
     33 }
     34 
     35 void CommandBufferHelper::SetAutomaticFlushes(bool enabled) {
     36   flush_automatically_ = enabled;
     37   CalcImmediateEntries(0);
     38 }
     39 
     40 bool CommandBufferHelper::IsContextLost() {
     41   if (!context_lost_) {
     42     context_lost_ = error::IsError(command_buffer()->GetLastError());
     43   }
     44   return context_lost_;
     45 }
     46 
     47 void CommandBufferHelper::CalcImmediateEntries(int waiting_count) {
     48   DCHECK_GE(waiting_count, 0);
     49 
     50   // Check if usable & allocated.
     51   if (!usable() || !HaveRingBuffer()) {
     52     immediate_entry_count_ = 0;
     53     return;
     54   }
     55 
     56   // Get maximum safe contiguous entries.
     57   const int32 curr_get = get_offset();
     58   if (curr_get > put_) {
     59     immediate_entry_count_ = curr_get - put_ - 1;
     60   } else {
     61     immediate_entry_count_ =
     62         total_entry_count_ - put_ - (curr_get == 0 ? 1 : 0);
     63   }
     64 
     65   // Limit entry count to force early flushing.
     66   if (flush_automatically_) {
     67     int32 limit =
     68         total_entry_count_ /
     69         ((curr_get == last_put_sent_) ? kAutoFlushSmall : kAutoFlushBig);
     70 
     71     int32 pending =
     72         (put_ + total_entry_count_ - last_put_sent_) % total_entry_count_;
     73 
     74     if (pending > 0 && pending >= limit) {
     75       // Time to force flush.
     76       immediate_entry_count_ = 0;
     77     } else {
     78       // Limit remaining entries, but not lower than waiting_count entries to
     79       // prevent deadlock when command size is greater than the flush limit.
     80       limit -= pending;
     81       limit = limit < waiting_count ? waiting_count : limit;
     82       immediate_entry_count_ =
     83           immediate_entry_count_ > limit ? limit : immediate_entry_count_;
     84     }
     85   }
     86 }
     87 
     88 bool CommandBufferHelper::AllocateRingBuffer() {
     89   if (!usable()) {
     90     return false;
     91   }
     92 
     93   if (HaveRingBuffer()) {
     94     return true;
     95   }
     96 
     97   int32 id = -1;
     98   scoped_refptr<Buffer> buffer =
     99       command_buffer_->CreateTransferBuffer(ring_buffer_size_, &id);
    100   if (id < 0) {
    101     ClearUsable();
    102     return false;
    103   }
    104 
    105   ring_buffer_ = buffer;
    106   ring_buffer_id_ = id;
    107   command_buffer_->SetGetBuffer(id);
    108   entries_ = static_cast<CommandBufferEntry*>(ring_buffer_->memory());
    109   total_entry_count_ = ring_buffer_size_ / sizeof(CommandBufferEntry);
    110   // Call to SetGetBuffer(id) above resets get and put offsets to 0.
    111   // No need to query it through IPC.
    112   put_ = 0;
    113   CalcImmediateEntries(0);
    114   return true;
    115 }
    116 
    117 void CommandBufferHelper::FreeResources() {
    118   if (HaveRingBuffer()) {
    119     command_buffer_->DestroyTransferBuffer(ring_buffer_id_);
    120     ring_buffer_id_ = -1;
    121     CalcImmediateEntries(0);
    122   }
    123 }
    124 
    125 void CommandBufferHelper::FreeRingBuffer() {
    126   CHECK((put_ == get_offset()) ||
    127       error::IsError(command_buffer_->GetLastState().error));
    128   FreeResources();
    129 }
    130 
    131 bool CommandBufferHelper::Initialize(int32 ring_buffer_size) {
    132   ring_buffer_size_ = ring_buffer_size;
    133   return AllocateRingBuffer();
    134 }
    135 
    136 CommandBufferHelper::~CommandBufferHelper() {
    137   FreeResources();
    138 }
    139 
    140 bool CommandBufferHelper::WaitForGetOffsetInRange(int32 start, int32 end) {
    141   if (!usable()) {
    142     return false;
    143   }
    144   command_buffer_->WaitForGetOffsetInRange(start, end);
    145   return command_buffer_->GetLastError() == gpu::error::kNoError;
    146 }
    147 
    148 void CommandBufferHelper::Flush() {
    149   // Wrap put_ before flush.
    150   if (put_ == total_entry_count_)
    151     put_ = 0;
    152 
    153   if (usable() && last_put_sent_ != put_) {
    154     last_flush_time_ = base::TimeTicks::Now();
    155     last_put_sent_ = put_;
    156     command_buffer_->Flush(put_);
    157     ++flush_generation_;
    158     CalcImmediateEntries(0);
    159   }
    160 }
    161 
    162 #if defined(CMD_HELPER_PERIODIC_FLUSH_CHECK)
    163 void CommandBufferHelper::PeriodicFlushCheck() {
    164   base::TimeTicks current_time = base::TimeTicks::Now();
    165   if (current_time - last_flush_time_ >
    166       base::TimeDelta::FromMicroseconds(kPeriodicFlushDelayInMicroseconds)) {
    167     Flush();
    168   }
    169 }
    170 #endif
    171 
    172 // Calls Flush() and then waits until the buffer is empty. Break early if the
    173 // error is set.
    174 bool CommandBufferHelper::Finish() {
    175   TRACE_EVENT0("gpu", "CommandBufferHelper::Finish");
    176   if (!usable()) {
    177     return false;
    178   }
    179   // If there is no work just exit.
    180   if (put_ == get_offset()) {
    181     return true;
    182   }
    183   DCHECK(HaveRingBuffer());
    184   Flush();
    185   if (!WaitForGetOffsetInRange(put_, put_))
    186     return false;
    187   DCHECK_EQ(get_offset(), put_);
    188 
    189   CalcImmediateEntries(0);
    190 
    191   return true;
    192 }
    193 
    194 // Inserts a new token into the command stream. It uses an increasing value
    195 // scheme so that we don't lose tokens (a token has passed if the current token
    196 // value is higher than that token). Calls Finish() if the token value wraps,
    197 // which will be rare.
    198 int32 CommandBufferHelper::InsertToken() {
    199   AllocateRingBuffer();
    200   if (!usable()) {
    201     return token_;
    202   }
    203   DCHECK(HaveRingBuffer());
    204   // Increment token as 31-bit integer. Negative values are used to signal an
    205   // error.
    206   token_ = (token_ + 1) & 0x7FFFFFFF;
    207   cmd::SetToken* cmd = GetCmdSpace<cmd::SetToken>();
    208   if (cmd) {
    209     cmd->Init(token_);
    210     if (token_ == 0) {
    211       TRACE_EVENT0("gpu", "CommandBufferHelper::InsertToken(wrapped)");
    212       // we wrapped
    213       Finish();
    214       DCHECK_EQ(token_, last_token_read());
    215     }
    216   }
    217   return token_;
    218 }
    219 
    220 // Waits until the current token value is greater or equal to the value passed
    221 // in argument.
    222 void CommandBufferHelper::WaitForToken(int32 token) {
    223   if (!usable() || !HaveRingBuffer()) {
    224     return;
    225   }
    226   // Return immediately if corresponding InsertToken failed.
    227   if (token < 0)
    228     return;
    229   if (token > token_) return;  // we wrapped
    230   if (last_token_read() >= token)
    231     return;
    232   Flush();
    233   command_buffer_->WaitForTokenInRange(token, token_);
    234 }
    235 
    236 // Waits for available entries, basically waiting until get >= put + count + 1.
    237 // It actually waits for contiguous entries, so it may need to wrap the buffer
    238 // around, adding a noops. Thus this function may change the value of put_. The
    239 // function will return early if an error occurs, in which case the available
    240 // space may not be available.
    241 void CommandBufferHelper::WaitForAvailableEntries(int32 count) {
    242   AllocateRingBuffer();
    243   if (!usable()) {
    244     return;
    245   }
    246   DCHECK(HaveRingBuffer());
    247   DCHECK(count < total_entry_count_);
    248   if (put_ + count > total_entry_count_) {
    249     // There's not enough room between the current put and the end of the
    250     // buffer, so we need to wrap. We will add noops all the way to the end,
    251     // but we need to make sure get wraps first, actually that get is 1 or
    252     // more (since put will wrap to 0 after we add the noops).
    253     DCHECK_LE(1, put_);
    254     int32 curr_get = get_offset();
    255     if (curr_get > put_ || curr_get == 0) {
    256       TRACE_EVENT0("gpu", "CommandBufferHelper::WaitForAvailableEntries");
    257       Flush();
    258       if (!WaitForGetOffsetInRange(1, put_))
    259         return;
    260       curr_get = get_offset();
    261       DCHECK_LE(curr_get, put_);
    262       DCHECK_NE(0, curr_get);
    263     }
    264     // Insert Noops to fill out the buffer.
    265     int32 num_entries = total_entry_count_ - put_;
    266     while (num_entries > 0) {
    267       int32 num_to_skip = std::min(CommandHeader::kMaxSize, num_entries);
    268       cmd::Noop::Set(&entries_[put_], num_to_skip);
    269       put_ += num_to_skip;
    270       num_entries -= num_to_skip;
    271     }
    272     put_ = 0;
    273   }
    274 
    275   // Try to get 'count' entries without flushing.
    276   CalcImmediateEntries(count);
    277   if (immediate_entry_count_ < count) {
    278     // Try again with a shallow Flush().
    279     Flush();
    280     CalcImmediateEntries(count);
    281     if (immediate_entry_count_ < count) {
    282       // Buffer is full.  Need to wait for entries.
    283       TRACE_EVENT0("gpu", "CommandBufferHelper::WaitForAvailableEntries1");
    284       if (!WaitForGetOffsetInRange(put_ + count + 1, put_))
    285         return;
    286       CalcImmediateEntries(count);
    287       DCHECK_GE(immediate_entry_count_, count);
    288     }
    289   }
    290 }
    291 
    292 
    293 }  // namespace gpu
    294