cc/resources/texture_uploader.cc

   1 // Copyright 2014 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 "cc/resources/texture_uploader.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "base/metrics/histogram.h"
  11 #include "base/trace_event/trace_event.h"
  12 #include "cc/base/math_util.h"
  13 #include "cc/resources/resource.h"
  14 #include "gpu/GLES2/gl2extchromium.h"
  15 #include "gpu/command_buffer/client/gles2_interface.h"
  16 #include "third_party/khronos/GLES2/gl2.h"
  17 #include "third_party/khronos/GLES2/gl2ext.h"
  18 #include "ui/gfx/geometry/rect.h"
  19 #include "ui/gfx/geometry/vector2d.h"
  20
  21 using gpu::gles2::GLES2Interface;
  22
  23 namespace {
  24
  25 // How many previous uploads to use when predicting future throughput.
  26 static const size_t kUploadHistorySizeMax = 1000;
  27 static const size_t kUploadHistorySizeInitial = 100;
  28
  29 // Global estimated number of textures per second to maintain estimates across
  30 // subsequent instances of TextureUploader.
  31 // More than one thread will not access this variable, so we do not need to
  32 // synchronize access.
  33 static const double kDefaultEstimatedTexturesPerSecond = 48.0 * 60.0;
  34
  35 // Flush interval when performing texture uploads.
  36 static const size_t kTextureUploadFlushPeriod = 4;
  37
  38 }  // anonymous namespace
  39
  40 namespace cc {
  41
  42 TextureUploader::Query::Query(GLES2Interface* gl)
  43     : gl_(gl),
  44       query_id_(0),
  45       value_(0),
  46       has_value_(false),
  47       is_non_blocking_(false) {
  48   gl_->GenQueriesEXT(1, &query_id_);
  49 }
  50
  51 TextureUploader::Query::~Query() { gl_->DeleteQueriesEXT(1, &query_id_); }
  52
  53 void TextureUploader::Query::Begin() {
  54   has_value_ = false;
  55   is_non_blocking_ = false;
  56   gl_->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM, query_id_);
  57 }
  58
  59 void TextureUploader::Query::End() {
  60   gl_->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
  61 }
  62
  63 bool TextureUploader::Query::IsPending() {
  64   unsigned available = 1;
  65   gl_->GetQueryObjectuivEXT(
  66       query_id_, GL_QUERY_RESULT_AVAILABLE_EXT, &available);
  67   return !available;
  68 }
  69
  70 unsigned TextureUploader::Query::Value() {
  71   if (!has_value_) {
  72     gl_->GetQueryObjectuivEXT(query_id_, GL_QUERY_RESULT_EXT, &value_);
  73     has_value_ = true;
  74   }
  75   return value_;
  76 }
  77
  78 TextureUploader::TextureUploader(GLES2Interface* gl)
  79     : gl_(gl),
  80       num_blocking_texture_uploads_(0),
  81       sub_image_size_(0),
  82       num_texture_uploads_since_last_flush_(0) {
  83   for (size_t i = kUploadHistorySizeInitial; i > 0; i--)
  84     textures_per_second_history_.insert(kDefaultEstimatedTexturesPerSecond);
  85 }
  86
  87 TextureUploader::~TextureUploader() {}
  88
  89 size_t TextureUploader::NumBlockingUploads() {
  90   ProcessQueries();
  91   return num_blocking_texture_uploads_;
  92 }
  93
  94 void TextureUploader::MarkPendingUploadsAsNonBlocking() {
  95   for (ScopedPtrDeque<Query>::iterator it = pending_queries_.begin();
  96        it != pending_queries_.end();
  97        ++it) {
  98     if ((*it)->is_non_blocking())
  99       continue;
 100
 101     num_blocking_texture_uploads_--;
 102     (*it)->mark_as_non_blocking();
 103   }
 104
 105   DCHECK(!num_blocking_texture_uploads_);
 106 }
 107
 108 double TextureUploader::EstimatedTexturesPerSecond() {
 109   ProcessQueries();
 110
 111   // Use the median as our estimate.
 112   std::multiset<double>::iterator median = textures_per_second_history_.begin();
 113   std::advance(median, textures_per_second_history_.size() / 2);
 114   return *median;
 115 }
 116
 117 void TextureUploader::BeginQuery() {
 118   // Check to see if any of the pending queries are free before allocating a
 119   // new one. If this is not done, queries may be allocated without bound.
 120   // http://crbug.com/398072
 121   if (available_queries_.empty())
 122     ProcessQueries();
 123
 124   if (available_queries_.empty())
 125     available_queries_.push_back(Query::Create(gl_));
 126
 127   available_queries_.front()->Begin();
 128 }
 129
 130 void TextureUploader::EndQuery() {
 131   available_queries_.front()->End();
 132   pending_queries_.push_back(available_queries_.take_front());
 133   num_blocking_texture_uploads_++;
 134 }
 135
 136 void TextureUploader::Upload(const uint8* image,
 137                              const gfx::Rect& image_rect,
 138                              const gfx::Rect& source_rect,
 139                              const gfx::Vector2d& dest_offset,
 140                              ResourceFormat format,
 141                              const gfx::Size& size) {
 142   CHECK(image_rect.Contains(source_rect));
 143
 144   bool is_full_upload = dest_offset.IsZero() && source_rect.size() == size;
 145
 146   if (is_full_upload)
 147     BeginQuery();
 148
 149   UploadWithMapTexSubImage(image, image_rect, source_rect, dest_offset, format);
 150
 151   if (is_full_upload)
 152     EndQuery();
 153
 154   num_texture_uploads_since_last_flush_++;
 155   if (num_texture_uploads_since_last_flush_ >= kTextureUploadFlushPeriod)
 156     Flush();
 157 }
 158
 159 void TextureUploader::Flush() {
 160   if (!num_texture_uploads_since_last_flush_)
 161     return;
 162
 163   gl_->ShallowFlushCHROMIUM();
 164
 165   num_texture_uploads_since_last_flush_ = 0;
 166 }
 167
 168 void TextureUploader::ReleaseCachedQueries() {
 169   ProcessQueries();
 170   available_queries_.clear();
 171 }
 172
 173 void TextureUploader::UploadWithTexSubImage(const uint8* image,
 174                                             const gfx::Rect& image_rect,
 175                                             const gfx::Rect& source_rect,
 176                                             const gfx::Vector2d& dest_offset,
 177                                             ResourceFormat format) {
 178   TRACE_EVENT0("cc", "TextureUploader::UploadWithTexSubImage");
 179
 180   // Early-out if this is a no-op, and assert that |image| be valid if this is
 181   // not a no-op.
 182   if (source_rect.IsEmpty())
 183     return;
 184   DCHECK(image);
 185
 186   // Offset from image-rect to source-rect.
 187   gfx::Vector2d offset(source_rect.origin() - image_rect.origin());
 188
 189   const uint8* pixel_source;
 190   unsigned bytes_per_pixel = BitsPerPixel(format) / 8;
 191   // Use 4-byte row alignment (OpenGL default) for upload performance.
 192   // Assuming that GL_UNPACK_ALIGNMENT has not changed from default.
 193   unsigned upload_image_stride =
 194       MathUtil::RoundUp(bytes_per_pixel * source_rect.width(), 4u);
 195
 196   if (upload_image_stride == image_rect.width() * bytes_per_pixel &&
 197       !offset.x()) {
 198     pixel_source = &image[image_rect.width() * bytes_per_pixel * offset.y()];
 199   } else {
 200     size_t needed_size = upload_image_stride * source_rect.height();
 201     if (sub_image_size_ < needed_size) {
 202       sub_image_.reset(new uint8[needed_size]);
 203       sub_image_size_ = needed_size;
 204     }
 205     // Strides not equal, so do a row-by-row memcpy from the
 206     // paint results into a temp buffer for uploading.
 207     for (int row = 0; row < source_rect.height(); ++row)
 208       memcpy(&sub_image_[upload_image_stride * row],
 209              &image[bytes_per_pixel *
 210                     (offset.x() + (offset.y() + row) * image_rect.width())],
 211              source_rect.width() * bytes_per_pixel);
 212
 213     pixel_source = &sub_image_[0];
 214   }
 215
 216   gl_->TexSubImage2D(GL_TEXTURE_2D,
 217                      0,
 218                      dest_offset.x(),
 219                      dest_offset.y(),
 220                      source_rect.width(),
 221                      source_rect.height(),
 222                      GLDataFormat(format),
 223                      GLDataType(format),
 224                      pixel_source);
 225 }
 226
 227 void TextureUploader::UploadWithMapTexSubImage(const uint8* image,
 228                                                const gfx::Rect& image_rect,
 229                                                const gfx::Rect& source_rect,
 230                                                const gfx::Vector2d& dest_offset,
 231                                                ResourceFormat format) {
 232   TRACE_EVENT0("cc", "TextureUploader::UploadWithMapTexSubImage");
 233
 234   // Early-out if this is a no-op, and assert that |image| be valid if this is
 235   // not a no-op.
 236   if (source_rect.IsEmpty())
 237     return;
 238   DCHECK(image);
 239   // Compressed textures have no implementation of mapTexSubImage.
 240   DCHECK_NE(ETC1, format);
 241
 242   // Offset from image-rect to source-rect.
 243   gfx::Vector2d offset(source_rect.origin() - image_rect.origin());
 244
 245   unsigned bytes_per_pixel = BitsPerPixel(format) / 8;
 246   // Use 4-byte row alignment (OpenGL default) for upload performance.
 247   // Assuming that GL_UNPACK_ALIGNMENT has not changed from default.
 248   unsigned upload_image_stride =
 249       MathUtil::RoundUp(bytes_per_pixel * source_rect.width(), 4u);
 250
 251   // Upload tile data via a mapped transfer buffer
 252   uint8* pixel_dest =
 253       static_cast<uint8*>(gl_->MapTexSubImage2DCHROMIUM(GL_TEXTURE_2D,
 254                                                         0,
 255                                                         dest_offset.x(),
 256                                                         dest_offset.y(),
 257                                                         source_rect.width(),
 258                                                         source_rect.height(),
 259                                                         GLDataFormat(format),
 260                                                         GLDataType(format),
 261                                                         GL_WRITE_ONLY));
 262
 263   if (!pixel_dest) {
 264     UploadWithTexSubImage(image, image_rect, source_rect, dest_offset, format);
 265     return;
 266   }
 267
 268   if (upload_image_stride == image_rect.width() * bytes_per_pixel &&
 269       !offset.x()) {
 270     memcpy(pixel_dest,
 271            &image[image_rect.width() * bytes_per_pixel * offset.y()],
 272            source_rect.height() * image_rect.width() * bytes_per_pixel);
 273   } else {
 274     // Strides not equal, so do a row-by-row memcpy from the
 275     // paint results into the pixel_dest.
 276     for (int row = 0; row < source_rect.height(); ++row) {
 277       memcpy(&pixel_dest[upload_image_stride * row],
 278              &image[bytes_per_pixel *
 279                     (offset.x() + (offset.y() + row) * image_rect.width())],
 280              source_rect.width() * bytes_per_pixel);
 281     }
 282   }
 283
 284   gl_->UnmapTexSubImage2DCHROMIUM(pixel_dest);
 285 }
 286
 287 void TextureUploader::ProcessQueries() {
 288   while (!pending_queries_.empty()) {
 289     if (pending_queries_.front()->IsPending())
 290       break;
 291
 292     unsigned us_elapsed = pending_queries_.front()->Value();
 293     UMA_HISTOGRAM_CUSTOM_COUNTS(
 294         "Renderer4.TextureGpuUploadTimeUS", us_elapsed, 0, 100000, 50);
 295
 296     // Clamp the queries to saner values in case the queries fail.
 297     us_elapsed = std::max(1u, us_elapsed);
 298     us_elapsed = std::min(15000u, us_elapsed);
 299
 300     if (!pending_queries_.front()->is_non_blocking())
 301       num_blocking_texture_uploads_--;
 302
 303     // Remove the min and max value from our history and insert the new one.
 304     double textures_per_second = 1.0 / (us_elapsed * 1e-6);
 305     if (textures_per_second_history_.size() >= kUploadHistorySizeMax) {
 306       textures_per_second_history_.erase(textures_per_second_history_.begin());
 307       textures_per_second_history_.erase(--textures_per_second_history_.end());
 308     }
 309     textures_per_second_history_.insert(textures_per_second);
 310
 311     available_queries_.push_back(pending_queries_.take_front());
 312   }
 313 }
 314
 315 }  // namespace cc