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