Print gpu/cache stats from DM.

dm/DMSrcSink.cpp

 #include "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkCommonFlags.h"
 #include "SkDocument.h"
 #include "SkMultiPictureDraw.h"
 #include "SkOSFile.h"
 #include "SkPictureRecorder.h"
 #include "SkRandom.h"
 #include "SkStream.h"
 
@@ skipping 127 matching lines @@
     : fContextType(ct)
     , fGpuAPI(api)
     , fSampleCount(samples)
     , fUseDFText(dfText)
     , fThreaded(threaded) {}
 
 int GPUSink::enclave() const {
     return fThreaded ? kAnyThread_Enclave : kGPU_Enclave;
 }
 
-Error GPUSink::draw(const Src& src, SkBitmap* dst, SkWStream*) const {
+DEFINE_bool(gpuStats, false, "Print GPU stats after each gpu sink runs? Requires verbose.");

[mtklein, 2015/02/02 16:23:17]

Seems like --gpuStats is plenty enough to control this.  Why don't we just
ignore --verbose?

+
+Error GPUSink::onDraw(const Src& src, SkBitmap* dst, SkWStream*) const {
     GrContextFactory factory;
     const SkISize size = src.size();
     const SkImageInfo info =
         SkImageInfo::Make(size.width(), size.height(), kN32_SkColorType, kPremul_SkAlphaType);
     SkAutoTUnref<SkSurface> surface(
             NewGpuSurface(&factory, fContextType, fGpuAPI, info, fSampleCount, fUseDFText));
     if (!surface) {
         return "Could not create a surface.";
     }
     SkCanvas* canvas = surface->getCanvas();
     Error err = src.draw(canvas);
     if (!err.isEmpty()) {
         return err;
     }
     canvas->flush();
+    if (FLAGS_gpuStats) {
+        canvas->getGrContext()->dumpCacheStats(&fVerboseLog);
+        canvas->getGrContext()->dumpGpuStats(&fVerboseLog);
+    }
     dst->allocPixels(info);
     canvas->readPixels(dst, 0,0);
     if (FLAGS_abandonGpuContext) {
         factory.abandonContexts();
     }
     return "";
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 PDFSink::PDFSink() {}
 
-Error PDFSink::draw(const Src& src, SkBitmap*, SkWStream* dst) const {
+Error PDFSink::onDraw(const Src& src, SkBitmap*, SkWStream* dst) const {
     // Print the given DM:Src to a PDF, breaking on 8.5x11 pages.
     SkAutoTUnref<SkDocument> doc(SkDocument::CreatePDF(dst));
 
     int width  = src.size().width(),
         height = src.size().height();
 
     const int kLetterWidth  = 612,  // 8.5 * 72
               kLetterHeight = 792;  // 11 * 72
     const SkRect letter = SkRect::MakeWH(SkIntToScalar(kLetterWidth),
                                          SkIntToScalar(kLetterHeight));
@@ skipping 18 matching lines @@
     }
     doc->close();
     dst->flush();
     return "";
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 SKPSink::SKPSink() {}
 
-Error SKPSink::draw(const Src& src, SkBitmap*, SkWStream* dst) const {
+Error SKPSink::onDraw(const Src& src, SkBitmap*, SkWStream* dst) const {
     SkSize size;
     size = src.size();
     SkPictureRecorder recorder;
     Error err = src.draw(recorder.beginRecording(size.width(), size.height()));
     if (!err.isEmpty()) {
         return err;
     }
     SkAutoTUnref<SkPicture> pic(recorder.endRecording());
     pic->serialize(dst);
     return "";
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 RasterSink::RasterSink(SkColorType colorType) : fColorType(colorType) {}
 
-Error RasterSink::draw(const Src& src, SkBitmap* dst, SkWStream*) const {
+Error RasterSink::onDraw(const Src& src, SkBitmap* dst, SkWStream*) const {
     const SkISize size = src.size();
     // If there's an appropriate alpha type for this color type, use it, otherwise use premul.
     SkAlphaType alphaType = kPremul_SkAlphaType;
     (void)SkColorTypeValidateAlphaType(fColorType, alphaType, &alphaType);
 
     dst->allocPixels(SkImageInfo::Make(size.width(), size.height(), fColorType, alphaType));
     dst->eraseColor(SK_ColorTRANSPARENT);
     SkCanvas canvas(*dst);
     return src.draw(&canvas);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 ViaMatrix::ViaMatrix(SkMatrix matrix, Sink* sink) : fMatrix(matrix), fSink(sink) {}
 
-Error ViaMatrix::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
+Error ViaMatrix::onDraw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
     // We turn our arguments into a Src, then draw that Src into our Sink to fill bitmap or stream.
     struct ProxySrc : public Src {
         const Src& fSrc;
         SkMatrix fMatrix;
         ProxySrc(const Src& src, SkMatrix matrix) : fSrc(src), fMatrix(matrix) {}
 
         Error draw(SkCanvas* canvas) const SK_OVERRIDE {
             canvas->concat(fMatrix);
             return fSrc.draw(canvas);
         }
         SkISize size() const SK_OVERRIDE { return fSrc.size(); }
         Name name() const SK_OVERRIDE { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(src, fMatrix);
     return fSink->draw(proxy, bitmap, stream);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 ViaPipe::ViaPipe(Sink* sink) : fSink(sink) {}
 
-Error ViaPipe::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
+Error ViaPipe::onDraw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
     // We turn ourselves into another Src that draws our argument into bitmap/stream via pipe.
     struct ProxySrc : public Src {
         const Src& fSrc;
         ProxySrc(const Src& src) : fSrc(src) {}
 
         Error draw(SkCanvas* canvas) const SK_OVERRIDE {
             SkISize size = this->size();
             PipeController controller(canvas, &SkImageDecoder::DecodeMemory);
             SkGPipeWriter pipe;
             const uint32_t kFlags = 0; // We mirror SkDeferredCanvas, which doesn't use any flags.
             return fSrc.draw(pipe.startRecording(&controller, kFlags, size.width(), size.height()));
         }
         SkISize size() const SK_OVERRIDE { return fSrc.size(); }
         Name name() const SK_OVERRIDE { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(src);
     return fSink->draw(proxy, bitmap, stream);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 ViaSerialization::ViaSerialization(Sink* sink) : fSink(sink) {}
 
-Error ViaSerialization::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
+Error ViaSerialization::onDraw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
     // Record our Src into a picture.
     SkSize size;
     size = src.size();
     SkPictureRecorder recorder;
     Error err = src.draw(recorder.beginRecording(size.width(), size.height()));
     if (!err.isEmpty()) {
         return err;
     }
     SkAutoTUnref<SkPicture> pic(recorder.endRecording());
 
@@ skipping 20 matching lines @@
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 ViaTiles::ViaTiles(int w, int h, SkBBHFactory* factory, Sink* sink)
     : fW(w)
     , fH(h)
     , fFactory(factory)
     , fSink(sink) {}
 
-Error ViaTiles::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
+Error ViaTiles::onDraw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
     // Record our Src into a picture.
     SkSize size;
     size = src.size();
     SkPictureRecorder recorder;
     Error err = src.draw(recorder.beginRecording(size.width(), size.height(), fFactory.get()));
     if (!err.isEmpty()) {
         return err;
     }
     SkAutoTUnref<SkPicture> pic(recorder.endRecording());
 
@@ skipping 38 matching lines @@
             surfaces.unrefAll();
             return "";
         }
         SkISize size() const SK_OVERRIDE { return fSize; }
         Name name() const SK_OVERRIDE { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(fW, fH, pic, src.size());
     return fSink->draw(proxy, bitmap, stream);
 }
 
 }  // namespace DM