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 "gpu/command_buffer/common/command_buffer.h"
     11 #include "gpu/command_buffer/common/trace_event.h"
     12 
     13 namespace gpu {
     14 
     15 CommandBufferHelper::CommandBufferHelper(CommandBuffer* command_buffer)
     16     : command_buffer_(command_buffer),
     17       ring_buffer_id_(-1),
     18       ring_buffer_size_(0),
     19       entries_(NULL),
     20       total_entry_count_(0),
     21       immediate_entry_count_(0),
     22       token_(0),
     23       put_(0),
     24       last_put_sent_(0),
     25 #if defined(CMD_HELPER_PERIODIC_FLUSH_CHECK)
     26       commands_issued_(0),
     27 #endif
     28       usable_(true),
     29       context_lost_(false),
     30       flush_automatically_(true),
     31       last_flush_time_(0),
     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_ = clock();
    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   clock_t current_time = clock();
    165   if (current_time - last_flush_time_ > kPeriodicFlushDelay * CLOCKS_PER_SEC)
    166     Flush();
    167 }
    168 #endif
    169 
    170 // Calls Flush() and then waits until the buffer is empty. Break early if the
    171 // error is set.
    172 bool CommandBufferHelper::Finish() {
    173   TRACE_EVENT0("gpu", "CommandBufferHelper::Finish");
    174   if (!usable()) {
    175     return false;
    176   }
    177   // If there is no work just exit.
    178   if (put_ == get_offset()) {
    179     return true;
    180   }
    181   DCHECK(HaveRingBuffer());
    182   Flush();
    183   if (!WaitForGetOffsetInRange(put_, put_))
    184     return false;
    185   DCHECK_EQ(get_offset(), put_);
    186 
    187   CalcImmediateEntries(0);
    188 
    189   return true;
    190 }
    191 
    192 // Inserts a new token into the command stream. It uses an increasing value
    193 // scheme so that we don't lose tokens (a token has passed if the current token
    194 // value is higher than that token). Calls Finish() if the token value wraps,
    195 // which will be rare.
    196 int32 CommandBufferHelper::InsertToken() {
    197   AllocateRingBuffer();
    198   if (!usable()) {
    199     return token_;
    200   }
    201   DCHECK(HaveRingBuffer());
    202   // Increment token as 31-bit integer. Negative values are used to signal an
    203   // error.
    204   token_ = (token_ + 1) & 0x7FFFFFFF;
    205   cmd::SetToken* cmd = GetCmdSpace<cmd::SetToken>();
    206   if (cmd) {
    207     cmd->Init(token_);
    208     if (token_ == 0) {
    209       TRACE_EVENT0("gpu", "CommandBufferHelper::InsertToken(wrapped)");
    210       // we wrapped
    211       Finish();
    212       DCHECK_EQ(token_, last_token_read());
    213     }
    214   }
    215   return token_;
    216 }
    217 
    218 // Waits until the current token value is greater or equal to the value passed
    219 // in argument.
    220 void CommandBufferHelper::WaitForToken(int32 token) {
    221   if (!usable() || !HaveRingBuffer()) {
    222     return;
    223   }
    224   // Return immediately if corresponding InsertToken failed.
    225   if (token < 0)
    226     return;
    227   if (token > token_) return;  // we wrapped
    228   if (last_token_read() >= token)
    229     return;
    230   Flush();
    231   command_buffer_->WaitForTokenInRange(token, token_);
    232 }
    233 
    234 // Waits for available entries, basically waiting until get >= put + count + 1.
    235 // It actually waits for contiguous entries, so it may need to wrap the buffer
    236 // around, adding a noops. Thus this function may change the value of put_. The
    237 // function will return early if an error occurs, in which case the available
    238 // space may not be available.
    239 void CommandBufferHelper::WaitForAvailableEntries(int32 count) {
    240   AllocateRingBuffer();
    241   if (!usable()) {
    242     return;
    243   }
    244   DCHECK(HaveRingBuffer());
    245   DCHECK(count < total_entry_count_);
    246   if (put_ + count > total_entry_count_) {
    247     // There's not enough room between the current put and the end of the
    248     // buffer, so we need to wrap. We will add noops all the way to the end,
    249     // but we need to make sure get wraps first, actually that get is 1 or
    250     // more (since put will wrap to 0 after we add the noops).
    251     DCHECK_LE(1, put_);
    252     int32 curr_get = get_offset();
    253     if (curr_get > put_ || curr_get == 0) {
    254       TRACE_EVENT0("gpu", "CommandBufferHelper::WaitForAvailableEntries");
    255       Flush();
    256       if (!WaitForGetOffsetInRange(1, put_))
    257         return;
    258       curr_get = get_offset();
    259       DCHECK_LE(curr_get, put_);
    260       DCHECK_NE(0, curr_get);
    261     }
    262     // Insert Noops to fill out the buffer.
    263     int32 num_entries = total_entry_count_ - put_;
    264     while (num_entries > 0) {
    265       int32 num_to_skip = std::min(CommandHeader::kMaxSize, num_entries);
    266       cmd::Noop::Set(&entries_[put_], num_to_skip);
    267       put_ += num_to_skip;
    268       num_entries -= num_to_skip;
    269     }
    270     put_ = 0;
    271   }
    272 
    273   // Try to get 'count' entries without flushing.
    274   CalcImmediateEntries(count);
    275   if (immediate_entry_count_ < count) {
    276     // Try again with a shallow Flush().
    277     Flush();
    278     CalcImmediateEntries(count);
    279     if (immediate_entry_count_ < count) {
    280       // Buffer is full.  Need to wait for entries.
    281       TRACE_EVENT0("gpu", "CommandBufferHelper::WaitForAvailableEntries1");
    282       if (!WaitForGetOffsetInRange(put_ + count + 1, put_))
    283         return;
    284       CalcImmediateEntries(count);
    285       DCHECK_GE(immediate_entry_count_, count);
    286     }
    287   }
    288 }
    289 
    290 
    291 }  // namespace gpu
    292