2021-11-05  Kimmo Kinnunen  <kkinnunen@apple.com>

        REGRESSION (iOS 15, GPU Process): Fails to load texture map

        https://bugs.webkit.org/show_bug.cgi?id=231471

        <rdar://problem/84328146>

        Reviewed by NOBODY (OOPS!).

        Clear the CGImage copy from the IOSurface CGContext after the IOSurface has

        been drawn to a bitmap CGContext. The CGImage stored in the IOSurface CGContext

        contains a malloc buffer of the data. This buffer is counted against GPU

        process memory consumption, causing GPU process jetsams.

        * platform/graphics/cg/ImageBufferIOSurfaceBackend.cpp:

        (WebCore::ImageBufferIOSurfaceBackend::draw):

        * platform/graphics/cg/ImageBufferIOSurfaceBackend.h:

2021-11-05  Kimmo Kinnunen  <kkinnunen@apple.com>

        REGRESSION (iOS 15, GPU Process): Fails to load texture map

        https://bugs.webkit.org/show_bug.cgi?id=231471

        <rdar://problem/84328146>

        Reviewed by NOBODY (OOPS!).

        Use the normal "draw image buffer" call to draw the image buffer

        to the shareble bitmap. Before, it was manually re-implementing this

        API call via the lower level calls.

        The drawImageBuffer call now fixes up the IOSurface -backed source

        ImageBuffers to not keep referencing to the CGImage that provided

        the data to the draw. Otherwise GPU process jetsams as the CGImage

        inside IOSurface is counted against GPU process memory limit.

        * GPUProcess/graphics/RemoteRenderingBackend.cpp:

        (WebKit::RemoteRenderingBackend::getShareableBitmapForImageBufferWithQualifiedIdentifier):

void ImageBufferIOSurfaceBackend::draw(GraphicsContext& destContext, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

{

    ImageBufferCGBackend::draw(destContext, destRect, srcRect, options);

    // Accelerated to/from unaccelerated image buffers need complex caching. We trust that

    // this is a one-off draw, and as such we clear the caches after each draw.

    // This is important for example in GPUP operation, where caches of big IOSurfaces

    // would cause GPUP memory limits to be exceeded.

    if (destContext.renderingMode() != context().renderingMode())

        invalidateCachedNativeImage();

}

    void draw(GraphicsContext& destContext, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) override;

2021-11-05  Kimmo Kinnunen  <kkinnunen@apple.com>

        REGRESSION (iOS 15, GPU Process): Fails to load texture map

        https://bugs.webkit.org/show_bug.cgi?id=231471

        <rdar://problem/84328146>

        Reviewed by NOBODY (OOPS!).

        Add a test that tries to assert that GraphicsContext::drawImageBuffer() does not increase

        memory footprint of the process. However, leave the test disabled as currently

        it seems that the WTF::memoryFootprint() measurement does not see all the

        memory releases the CG does.

        * TestWebKitAPI/Tests/WebCore/ImageBufferTests.cpp:

        (TestWebKitAPI::memoryFootprintChangedBy):

        (TestWebKitAPI::imageBufferPixelIs):

        (TestWebKitAPI::TEST):

#include <WebCore/Color.h>

#include <cmath>

#include <wtf/MemoryFootprint.h>

static ::testing::AssertionResult memoryFootprintChangedBy(size_t& lastFootprint, double expectedChange, double error)

{

    WTF::releaseFastMallocFreeMemory();

    size_t newFootprint = memoryFootprint();

    size_t oldFootprint = std::exchange(lastFootprint, newFootprint);

    double change = static_cast<double>(newFootprint) - oldFootprint;

    if (change - expectedChange > error)

        return ::testing::AssertionFailure() << "Footprint changed by " << change << ". Expected at most " << expectedChange << "+-" << error;

    return ::testing::AssertionSuccess();

}

static ::testing::AssertionResult imageBufferPixelIs(Color expected, ImageBuffer& imageBuffer, int x, int y)

{

    PixelBufferFormat format { AlphaPremultiplication::Unpremultiplied, PixelFormat::RGBA8, DestinationColorSpace::SRGB() };

    auto frontPixelBuffer = imageBuffer.getPixelBuffer(format, { x, y, 1, 1 });

    auto& data = frontPixelBuffer->data();

    auto got = Color { SRGBA<uint8_t> { data.item(0), data.item(1), data.item(2), data.item(3) } };

    if (got != expected)

        return ::testing::AssertionFailure() << "color is not expected."; // FIXME: implement Color <<.

    return ::testing::AssertionSuccess();

}

// Test that drawing an accelerated ImageBuffer to an unaccelerated does not store extra

// memory to the accelerated ImageBuffer.

// FIXME: The test is disabled as it appears that WTF::memoryFootprint() is not exact enough to

// test that GraphicsContext::drawImageBitmap() does not keep extra memory around.

// However, if the test is paused at the memory measurement location and the process is inspected

// manually with the memory tools, the footprint is as expected, e.g. drawBitmapImage does not

// persist additional memory.

TEST(ImageBufferTests, DISABLED_DrawImageBufferDoesNotReferenceExtraMemory)

{

    auto colorSpace = DestinationColorSpace::SRGB();

    auto pixelFormat = PixelFormat::BGRA8;

    FloatSize logicalSize { 4096, 4096 };

    float scale = 1;

    size_t footprintError = 1024 * 1024;

    size_t logicalSizeBytes = logicalSize.width() * logicalSize.height() * 4;

    // FIXME: Logically this fuzz amount  should not exist.

    // WTF::memoryFootprint() does not return the same amount of memory as

    // the `footprint` command or the leak tools.

    // At the time of writing, the bug case would report drawImageBitmap footprint

    // as ~130mb, and fixed case would report ~67mb.

    size_t drawImageBitmapUnaccountedFootprint = logicalSizeBytes + 3 * 1024 * 1024;

    {

        // Make potential accelerated drawing backend instantiate roughly the global structures needed for this test.

        auto accelerated = ImageBuffer::create(logicalSize, RenderingMode::Accelerated, scale, colorSpace, pixelFormat, nullptr);

        auto fillRect = FloatRect { { }, logicalSize };

        accelerated->context().fillRect(fillRect, Color::green);

        EXPECT_TRUE(imageBufferPixelIs(Color::green, *accelerated, fillRect.maxX() - 1, fillRect.maxY() - 1));

    }

    WTF::releaseFastMallocFreeMemory();

    auto initialFootprint = memoryFootprint();

    auto lastFootprint = initialFootprint;

    EXPECT_GT(lastFootprint, 0u);

    auto accelerated = ImageBuffer::create(logicalSize, RenderingMode::Accelerated, scale, colorSpace, pixelFormat, nullptr);

    auto fillRect = FloatRect { { }, logicalSize };

    accelerated->context().fillRect(fillRect, Color::green);

    accelerated->flushContext();

    EXPECT_TRUE(memoryFootprintChangedBy(lastFootprint, logicalSizeBytes, footprintError));

    auto unaccelerated = ImageBuffer::create(logicalSize, RenderingMode::Unaccelerated, scale, colorSpace, pixelFormat, nullptr);

    unaccelerated->context().fillRect(fillRect, Color::yellow);

    EXPECT_TRUE(imageBufferPixelIs(Color::yellow, *unaccelerated, fillRect.maxX() - 1, fillRect.maxY() - 1));

    EXPECT_TRUE(memoryFootprintChangedBy(lastFootprint, logicalSizeBytes, footprintError));

    // The purpose of the whole test is to test that drawImageBuffer does not increase

    // memory footprint.

    unaccelerated->context().drawImageBuffer(*accelerated, FloatRect { { }, logicalSize }, FloatRect { { }, logicalSize }, { WebCore::CompositeOperator::Copy });

    EXPECT_TRUE(imageBufferPixelIs(Color::green, *unaccelerated, fillRect.maxX() - 1, fillRect.maxY() - 1));

    EXPECT_TRUE(memoryFootprintChangedBy(lastFootprint, 0 + drawImageBitmapUnaccountedFootprint, footprintError));

    // sleep(10000); // Enable this to inspect the process manually.

    accelerated = nullptr;

    unaccelerated = nullptr;

    lastFootprint = initialFootprint;

    EXPECT_TRUE(memoryFootprintChangedBy(lastFootprint, 0, footprintError));

}