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 const int kCommandsPerFlushCheck = 100;
     16 
     17 #if !defined(OS_ANDROID)
     18 const double kFlushDelay = 1.0 / (5.0 * 60.0);
     19 #endif
     20 
     21 CommandBufferHelper::CommandBufferHelper(CommandBuffer* command_buffer)
     22     : command_buffer_(command_buffer),
     23       ring_buffer_id_(-1),
     24       ring_buffer_size_(0),
     25       entries_(NULL),
     26       total_entry_count_(0),
     27       token_(0),
     28       put_(0),
     29       last_put_sent_(0),
     30       commands_issued_(0),
     31       usable_(true),
     32       context_lost_(false),
     33       flush_automatically_(true),
     34       last_flush_time_(0) {
     35 }
     36 
     37 void CommandBufferHelper::SetAutomaticFlushes(bool enabled) {
     38   flush_automatically_ = enabled;
     39 }
     40 
     41 bool CommandBufferHelper::IsContextLost() {
     42   if (!context_lost_) {
     43     context_lost_ = error::IsError(command_buffer()->GetLastError());
     44   }
     45   return context_lost_;
     46 }
     47 
     48 bool CommandBufferHelper::AllocateRingBuffer() {
     49   if (!usable()) {
     50     return false;
     51   }
     52 
     53   if (HaveRingBuffer()) {
     54     return true;
     55   }
     56 
     57   int32 id = -1;
     58   Buffer buffer = command_buffer_->CreateTransferBuffer(ring_buffer_size_, &id);
     59   if (id < 0) {
     60     ClearUsable();
     61     return false;
     62   }
     63 
     64   ring_buffer_ = buffer;
     65   ring_buffer_id_ = id;
     66   command_buffer_->SetGetBuffer(id);
     67 
     68   // TODO(gman): Do we really need to call GetState here? We know get & put = 0
     69   // Also do we need to check state.num_entries?
     70   CommandBuffer::State state = command_buffer_->GetState();
     71   entries_ = static_cast<CommandBufferEntry*>(ring_buffer_.ptr);
     72   int32 num_ring_buffer_entries =
     73       ring_buffer_size_ / sizeof(CommandBufferEntry);
     74   if (num_ring_buffer_entries > state.num_entries) {
     75     ClearUsable();
     76     return false;
     77   }
     78 
     79   total_entry_count_ = num_ring_buffer_entries;
     80   put_ = state.put_offset;
     81   return true;
     82 }
     83 
     84 void CommandBufferHelper::FreeResources() {
     85   if (HaveRingBuffer()) {
     86     command_buffer_->DestroyTransferBuffer(ring_buffer_id_);
     87     ring_buffer_id_ = -1;
     88   }
     89 }
     90 
     91 void CommandBufferHelper::FreeRingBuffer() {
     92   CHECK((put_ == get_offset()) ||
     93       error::IsError(command_buffer_->GetLastState().error));
     94   FreeResources();
     95 }
     96 
     97 bool CommandBufferHelper::Initialize(int32 ring_buffer_size) {
     98   ring_buffer_size_ = ring_buffer_size;
     99   return AllocateRingBuffer();
    100 }
    101 
    102 CommandBufferHelper::~CommandBufferHelper() {
    103   FreeResources();
    104 }
    105 
    106 bool CommandBufferHelper::FlushSync() {
    107   if (!usable()) {
    108     return false;
    109   }
    110   last_flush_time_ = clock();
    111   last_put_sent_ = put_;
    112   CommandBuffer::State state = command_buffer_->FlushSync(put_, get_offset());
    113   return state.error == error::kNoError;
    114 }
    115 
    116 void CommandBufferHelper::Flush() {
    117   if (usable() && last_put_sent_ != put_) {
    118     last_flush_time_ = clock();
    119     last_put_sent_ = put_;
    120     command_buffer_->Flush(put_);
    121   }
    122 }
    123 
    124 // Calls Flush() and then waits until the buffer is empty. Break early if the
    125 // error is set.
    126 bool CommandBufferHelper::Finish() {
    127   TRACE_EVENT0("gpu", "CommandBufferHelper::Finish");
    128   if (!usable()) {
    129     return false;
    130   }
    131   // If there is no work just exit.
    132   if (put_ == get_offset()) {
    133     return true;
    134   }
    135   DCHECK(HaveRingBuffer());
    136   do {
    137     // Do not loop forever if the flush fails, meaning the command buffer reader
    138     // has shutdown.
    139     if (!FlushSync())
    140       return false;
    141   } while (put_ != get_offset());
    142 
    143   return true;
    144 }
    145 
    146 // Inserts a new token into the command stream. It uses an increasing value
    147 // scheme so that we don't lose tokens (a token has passed if the current token
    148 // value is higher than that token). Calls Finish() if the token value wraps,
    149 // which will be rare.
    150 int32 CommandBufferHelper::InsertToken() {
    151   AllocateRingBuffer();
    152   if (!usable()) {
    153     return token_;
    154   }
    155   DCHECK(HaveRingBuffer());
    156   // Increment token as 31-bit integer. Negative values are used to signal an
    157   // error.
    158   token_ = (token_ + 1) & 0x7FFFFFFF;
    159   cmd::SetToken* cmd = GetCmdSpace<cmd::SetToken>();
    160   if (cmd) {
    161     cmd->Init(token_);
    162     if (token_ == 0) {
    163       TRACE_EVENT0("gpu", "CommandBufferHelper::InsertToken(wrapped)");
    164       // we wrapped
    165       Finish();
    166       DCHECK_EQ(token_, last_token_read());
    167     }
    168   }
    169   return token_;
    170 }
    171 
    172 // Waits until the current token value is greater or equal to the value passed
    173 // in argument.
    174 void CommandBufferHelper::WaitForToken(int32 token) {
    175   if (!usable() || !HaveRingBuffer()) {
    176     return;
    177   }
    178   // Return immediately if corresponding InsertToken failed.
    179   if (token < 0)
    180     return;
    181   if (token > token_) return;  // we wrapped
    182   while (last_token_read() < token) {
    183     if (get_offset() == put_) {
    184       LOG(FATAL) << "Empty command buffer while waiting on a token.";
    185       return;
    186     }
    187     // Do not loop forever if the flush fails, meaning the command buffer reader
    188     // has shutdown.
    189     if (!FlushSync())
    190       return;
    191   }
    192 }
    193 
    194 // Waits for available entries, basically waiting until get >= put + count + 1.
    195 // It actually waits for contiguous entries, so it may need to wrap the buffer
    196 // around, adding a noops. Thus this function may change the value of put_. The
    197 // function will return early if an error occurs, in which case the available
    198 // space may not be available.
    199 void CommandBufferHelper::WaitForAvailableEntries(int32 count) {
    200   AllocateRingBuffer();
    201   if (!usable()) {
    202     return;
    203   }
    204   DCHECK(HaveRingBuffer());
    205   DCHECK(count < total_entry_count_);
    206   if (put_ + count > total_entry_count_) {
    207     // There's not enough room between the current put and the end of the
    208     // buffer, so we need to wrap. We will add noops all the way to the end,
    209     // but we need to make sure get wraps first, actually that get is 1 or
    210     // more (since put will wrap to 0 after we add the noops).
    211     DCHECK_LE(1, put_);
    212     if (get_offset() > put_ || get_offset() == 0) {
    213       TRACE_EVENT0("gpu", "CommandBufferHelper::WaitForAvailableEntries");
    214       while (get_offset() > put_ || get_offset() == 0) {
    215         // Do not loop forever if the flush fails, meaning the command buffer
    216         // reader has shutdown.
    217         if (!FlushSync())
    218           return;
    219       }
    220     }
    221     // Insert Noops to fill out the buffer.
    222     int32 num_entries = total_entry_count_ - put_;
    223     while (num_entries > 0) {
    224       int32 num_to_skip = std::min(CommandHeader::kMaxSize, num_entries);
    225       cmd::Noop::Set(&entries_[put_], num_to_skip);
    226       put_ += num_to_skip;
    227       num_entries -= num_to_skip;
    228     }
    229     put_ = 0;
    230   }
    231   if (AvailableEntries() < count) {
    232     TRACE_EVENT0("gpu", "CommandBufferHelper::WaitForAvailableEntries1");
    233     while (AvailableEntries() < count) {
    234       // Do not loop forever if the flush fails, meaning the command buffer
    235       // reader has shutdown.
    236       if (!FlushSync())
    237         return;
    238     }
    239   }
    240   // Force a flush if the buffer is getting half full, or even earlier if the
    241   // reader is known to be idle.
    242   int32 pending =
    243       (put_ + total_entry_count_ - last_put_sent_) % total_entry_count_;
    244   int32 limit = total_entry_count_ /
    245       ((get_offset() == last_put_sent_) ? 16 : 2);
    246   if (pending > limit) {
    247     Flush();
    248   } else if (flush_automatically_ &&
    249              (commands_issued_ % kCommandsPerFlushCheck == 0)) {
    250 #if !defined(OS_ANDROID)
    251     // Allow this command buffer to be pre-empted by another if a "reasonable"
    252     // amount of work has been done. On highend machines, this reduces the
    253     // latency of GPU commands. However, on Android, this can cause the
    254     // kernel to thrash between generating GPU commands and executing them.
    255     clock_t current_time = clock();
    256     if (current_time - last_flush_time_ > kFlushDelay * CLOCKS_PER_SEC)
    257       Flush();
    258 #endif
    259   }
    260 }
    261 
    262 CommandBufferEntry* CommandBufferHelper::GetSpace(uint32 entries) {
    263   AllocateRingBuffer();
    264   if (!usable()) {
    265     return NULL;
    266   }
    267   DCHECK(HaveRingBuffer());
    268   ++commands_issued_;
    269   WaitForAvailableEntries(entries);
    270   CommandBufferEntry* space = &entries_[put_];
    271   put_ += entries;
    272   DCHECK_LE(put_, total_entry_count_);
    273   if (put_ == total_entry_count_) {
    274     put_ = 0;
    275   }
    276   return space;
    277 }
    278 
    279 }  // namespace gpu
    280