Metal debug render tests

platform/ios/benchmark/BUILD.bazel

@@ -7,6 +7,7 @@ filegroup(
         "MBXBenchAppDelegate.mm",
         "MBXBenchViewController.mm",
         "locations.cpp",
+        "file_source.cpp",
     ],
     visibility = ["//platform:__pkg__"],
 )
@@ -17,6 +18,7 @@ filegroup(
         "MBXBenchAppDelegate.h",
         "MBXBenchViewController.h",
         "locations.hpp",
+        "file_source.hpp",
     ],
     visibility = ["//platform:__pkg__"],
 )

platform/ios/benchmark/MBXBenchViewController.mm

@@ -4,14 +4,17 @@
 #import "MLNOfflineStorage_Private.h"
 #import "MLNSettings_Private.h"
 
+#include "file_source.hpp"
 #include "locations.hpp"
 
 #include <chrono>
 
 #include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/gfx/headless_frontend.hpp>
 #include <mbgl/map/map.hpp>
+#include <mbgl/storage/file_source_manager.hpp>
 #include <mbgl/style/style.hpp>
+#include <mbgl/util/run_loop.hpp>
 
 @protocol BenchMapDelegate <NSObject>
 - (void)mapDidFinishRenderingFrameFullyRendered:(BOOL)fullyRendered
@@ -44,6 +47,7 @@ @interface MBXBenchViewController () <BenchMapDelegate> {
     std::unique_ptr<BenchMapObserver> observer;
     std::unique_ptr<mbgl::HeadlessFrontend> frontend;
     std::unique_ptr<mbgl::Map> map;
+    mbgl::util::RunLoop runLoop;
 }
 
 @property (nonatomic) UIImageView *imageView;
@@ -93,8 +97,9 @@ - (void)viewDidAppear:(BOOL)animated
     self.imageView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
     [self.view addSubview:self.imageView];
 
-    mbgl::Size viewSize = { static_cast<uint32_t>(self.view.bounds.size.width),
-                            static_cast<uint32_t>(self.view.bounds.size.height) };
+    //mbgl::Size viewSize = { static_cast<uint32_t>(self.view.bounds.size.width),
+    //                        static_cast<uint32_t>(self.view.bounds.size.height) };
+    mbgl::Size viewSize = { 512, 512 };
     auto pixelRatio = [[UIScreen mainScreen] scale];
 
     observer = std::make_unique<BenchMapObserver>(self);
@@ -104,24 +109,41 @@ - (void)viewDidAppear:(BOOL)animated
         mbgl::gfx::HeadlessBackend::SwapBehaviour::Flush,
         mbgl::gfx::ContextMode::Unique,
         /* localFontFamily */ std::nullopt,
-        /* invalidateOnUpdate */ false
+        /* invalidateOnUpdate */ true
     );
 
     mbgl::MapOptions mapOptions;
-    mapOptions.withMapMode(mbgl::MapMode::Continuous)
+    mapOptions.withMapMode(mbgl::MapMode::Static)
               .withSize(viewSize)
               .withPixelRatio(pixelRatio)
               .withConstrainMode(mbgl::ConstrainMode::None)
               .withViewportMode(mbgl::ViewportMode::Default)
               .withCrossSourceCollisions(true);
 
+    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+    NSString *documentsDirectory = [paths objectAtIndex:0];
+    NSString* cachePath = [documentsDirectory stringByAppendingPathComponent:@"cache-style.db"];
+
     mbgl::TileServerOptions* tileServerOptions = [[MLNSettings sharedSettings] tileServerOptionsInternal];
     mbgl::ResourceOptions resourceOptions;
-    resourceOptions.withCachePath(MLNOfflineStorage.sharedOfflineStorage.databasePath.UTF8String)
+    resourceOptions.withCachePath(cachePath.UTF8String)
                    .withAssetPath([NSBundle mainBundle].resourceURL.path.UTF8String)
                    .withTileServerOptions(*tileServerOptions);
     mbgl::ClientOptions clientOptions;
 
+    auto* fileSourceManager = mbgl::FileSourceManager::get();
+
+    auto resourceLoaderFactory = fileSourceManager->unRegisterFileSourceFactory(
+        mbgl::FileSourceType::ResourceLoader);
+    auto factory = [defaultFactory = std::move(resourceLoaderFactory)](const mbgl::ResourceOptions& resourceOptions,
+                                                                       const mbgl::ClientOptions& clientOptions) {
+        assert(defaultFactory);
+        std::shared_ptr<mbgl::FileSource> fileSource = defaultFactory(resourceOptions, clientOptions);
+        return std::make_unique<mbgl::ProxyFileSource>(std::move(fileSource), resourceOptions, clientOptions);
+    };
+
+    fileSourceManager->registerFileSourceFactory(mbgl::FileSourceType::ResourceLoader, std::move(factory));
+
     auto apiKey = [[MLNSettings sharedSettings] apiKey];
     if (apiKey) {
         resourceOptions.withApiKey([apiKey UTF8String]);
@@ -130,9 +152,21 @@ - (void)viewDidAppear:(BOOL)animated
     map = std::make_unique<mbgl::Map>(*frontend, *observer, mapOptions, resourceOptions, clientOptions);
     map->setSize(viewSize);
     map->setDebug(mbgl::MapDebugOptions::NoDebug);
-    map->getStyle().loadURL([url.absoluteString UTF8String]);
+    //map->getStyle().loadURL([url.absoluteString UTF8String]);
+
+    NSString* jsonPath = [documentsDirectory stringByAppendingPathComponent:@"style.json"];
+    NSData* jsonData = [NSData dataWithContentsOfFile:jsonPath];
+    NSString* jsonString = [[NSString alloc] initWithBytes:[jsonData bytes]
+                                                    length:[jsonData length]
+                                                  encoding:NSUTF8StringEncoding];
 
-    [self startBenchmarkIteration];
+    map->getStyle().loadJSON(jsonString.UTF8String);
+    //map->setDebug(mbgl::MapDebugOptions::Collision | mbgl::MapDebugOptions::TileBorders);
+
+    //map->getStyle().loadURL("https://api.maptiler.com/maps/2f4c4899-e695-4c8b-a4ef-92fa9d2740ff/style.json?key=G4MQXsYbLiUxOu3SV4lh");
+
+    //[self startBenchmarkIteration];
+    [self renderFrame];
 }
 
 // For setting the filename
@@ -194,17 +228,19 @@ - (void)renderFrame
 {
     mbgl::gfx::BackendScope guard{*(frontend->getBackend())};
 
-    frontend->renderFrame();
+    //frontend->renderFrame();
+
+    //auto image = frontend->readStillImage();
 
-    auto image = frontend->readStillImage();
+    auto result = frontend->render(*map);
 
     CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
     CGContextRef bitmapContext = CGBitmapContextCreate(
-       image.data.get(),
-       image.size.width,
-       image.size.height,
+       result.image.data.get(),
+       result.image.size.width,
+       result.image.size.height,
        8,
-       4 * image.size.width,
+       4 * result.image.size.width,
        colorSpace,
        kCGImageAlphaPremultipliedLast | kCGBitmapByteOrderDefault
     );
@@ -288,7 +324,11 @@ - (void)mapDidFinishRenderingFrameFullyRendered:(__unused BOOL)fullyRendered
                               frameEncodingTime:(double)frameEncodingTime
                              frameRenderingTime:(double)frameRenderingTime
 {
-    if (state == State::Benchmarking)
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self renderFrame];
+    });
+
+    /*if (state == State::Benchmarking)
     {
         frames++;
         totalFrameEncodingTime += frameEncodingTime;
@@ -344,7 +384,7 @@ - (void)mapDidFinishRenderingFrameFullyRendered:(__unused BOOL)fullyRendered
             [self renderFrame];
         });
         return;
-    }
+    }*/
 }
 
 - (NSUInteger)supportedInterfaceOrientations

platform/ios/benchmark/file_source.cpp

@@ -0,0 +1,126 @@
+#include <mbgl/storage/file_source_manager.hpp>
+#include <mbgl/storage/resource.hpp>
+#include <mbgl/storage/resource_options.hpp>
+#include <mbgl/util/async_request.hpp>
+#include <mbgl/util/client_options.hpp>
+#include <mbgl/util/logging.hpp>
+
+#include <atomic>
+
+#include "file_source.hpp"
+
+namespace mbgl {
+
+std::atomic_size_t requestCount{0};
+std::atomic_size_t transferredSize{0};
+std::atomic_bool active{false};
+std::atomic_bool offline{true};
+
+ProxyFileSource::ProxyFileSource(std::shared_ptr<FileSource> defaultResourceLoader_,
+                                 const ResourceOptions& resourceOptions_,
+                                 const ClientOptions& clientOptions_)
+    : defaultResourceLoader(std::move(defaultResourceLoader_)),
+      resourceOptions(resourceOptions_.clone()),
+      clientOptions(clientOptions_.clone()) {
+    assert(defaultResourceLoader);
+    if (offline) {
+        std::shared_ptr<FileSource> dbfs = FileSourceManager::get()->getFileSource(
+            FileSourceType::Database, resourceOptions_, clientOptions_);
+        dbfs->setProperty(READ_ONLY_MODE_KEY, true);
+    }
+}
+
+ProxyFileSource::~ProxyFileSource() = default;
+
+std::unique_ptr<AsyncRequest> ProxyFileSource::request(const Resource& resource, Callback callback) {
+    auto transformed = resource;
+
+    // If offline, force always loading the resource from the cache
+    // so we don't make any network request.
+    if (offline) {
+        transformed.loadingMethod = Resource::LoadingMethod::CacheOnly;
+    }
+
+    // This is needed for compatibility with the style tests that
+    // are using local:// instead of http:// which is the schema
+    // we support for cached files.
+    if (transformed.url.compare(0, 8, "local://") == 0) {
+        transformed.url.replace(0, 8, "http://");
+
+        if (transformed.kind == Resource::Kind::Tile && transformed.tileData) {
+            transformed.tileData->urlTemplate.replace(0, 8, "http://");
+        }
+    }
+
+    if (transformed.url.compare(0, 22, "http://localhost:2900/") == 0) {
+        transformed.url.replace(0, 22, "http://");
+
+        if (transformed.kind == Resource::Kind::Tile && transformed.tileData) {
+            transformed.tileData->urlTemplate.replace(0, 22, "http://");
+        }
+    }
+
+    return defaultResourceLoader->request(transformed, [=](Response response) {
+        if (transformed.loadingMethod == Resource::LoadingMethod::CacheOnly && response.noContent) {
+            if (transformed.kind == Resource::Kind::Tile && transformed.tileData) {
+                mbgl::Log::Info(
+                    mbgl::Event::Database,
+                    "Resource not found in cache: " + transformed.url + "(" + transformed.tileData->urlTemplate + ")");
+            } else {
+                mbgl::Log::Info(mbgl::Event::Database, "Resource not found in cache: " + transformed.url);
+            }
+        }
+
+        std::size_t size = response.data != nullptr ? response.data->size() : 0;
+        if (active) {
+            requestCount++;
+            transferredSize += size;
+        }
+        callback(response);
+    });
+}
+
+void ProxyFileSource::setResourceOptions(ResourceOptions options) {
+    resourceOptions = options;
+}
+
+ResourceOptions ProxyFileSource::getResourceOptions() {
+    return resourceOptions.clone();
+}
+
+void ProxyFileSource::setClientOptions(ClientOptions options) {
+    clientOptions = options;
+}
+
+ClientOptions ProxyFileSource::getClientOptions() {
+    return clientOptions.clone();
+}
+
+// static
+void ProxyFileSource::setOffline(bool status) {
+    offline = status;
+}
+
+// static
+void ProxyFileSource::setTrackingActive(bool active_) {
+    active = active_;
+    requestCount = 0;
+    transferredSize = 0;
+}
+
+// static
+bool ProxyFileSource::isTrackingActive() {
+    return active;
+}
+
+// static
+size_t ProxyFileSource::getRequestCount() {
+    return requestCount;
+}
+
+// static
+size_t ProxyFileSource::getTransferredSize() {
+    return transferredSize;
+}
+
+} // namespace mbgl

platform/ios/benchmark/file_source.hpp

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <mbgl/storage/file_source.hpp>
+
+namespace mbgl {
+
+class ClientOptions;
+class ResourceOptions;
+
+class ProxyFileSource : public FileSource {
+public:
+    ProxyFileSource(std::shared_ptr<FileSource>, const ResourceOptions&, const ClientOptions&);
+    ~ProxyFileSource();
+
+    std::unique_ptr<AsyncRequest> request(const Resource&, Callback) override;
+    bool canRequest(const Resource&) const override { return true; }
+
+    /**
+     * @brief Flag to change the networking mode of the file source.
+     */
+    static void setOffline(bool);
+
+    /**
+     * @brief Starts/stops metrics tracking.
+     */
+    static void setTrackingActive(bool);
+
+    /**
+     * @brief Returns metrics tracking status.
+     */
+    static bool isTrackingActive();
+
+    /**
+     * @brief Returns the total amount of requests.
+     *
+     * @return size_t
+     */
+    static size_t getRequestCount();
+
+    /**
+     * @brief Returns the size of transferred data (in bytes).
+     *
+     * @return size_t
+     */
+    static size_t getTransferredSize();
+
+    void setResourceOptions(ResourceOptions) override;
+    ResourceOptions getResourceOptions() override;
+
+    void setClientOptions(ClientOptions) override;
+    ClientOptions getClientOptions() override;
+
+private:
+    std::shared_ptr<FileSource> defaultResourceLoader;
+    ResourceOptions resourceOptions;
+    ClientOptions clientOptions;
+};
+
+} // namespace mbgl

render-test/manifest_parser.cpp

@@ -280,6 +280,10 @@ std::optional<Manifest> ManifestParser::parseManifest(const std::string& manifes
             continue;
         }
 
+        /*if (testPath.path().string().find("text-max-width/zoom-and-property-function") == std::string::npos) {
+            continue;
+        }*/
+
         if (testPath.path().filename() == "style.json") {
             const auto defaultExpectationPath{std::move(mbgl::filesystem::path(testPath).remove_filename())};
             const auto rootLength = manifest.testRootPath.length();

render-test/metadata.hpp

@@ -152,7 +152,7 @@ struct TestMetadata {
     // error message: "Failed to find expectations for..., to prevent
     // unit test error by missing metric.json, can turn on 'ignoreProbing'
     // to prevent the unit test fail, and just verify the render result.
-    bool ignoreProbing = false;
+    bool ignoreProbing = true;
 
     mbgl::Size size{512u, 512u};
     float pixelRatio = 1.0f;

src/mbgl/map/map_impl.cpp

@@ -135,13 +135,10 @@ void Map::Impl::onDidFinishRenderingFrame(RenderMode renderMode,
                                           double frameRenderingTime) {
     rendererFullyLoaded = renderMode == RenderMode::Full;
 
-    if (mode == MapMode::Continuous) {
-        observer.onDidFinishRenderingFrame({MapObserver::RenderMode(renderMode),
-                                            needsRepaint,
-                                            placemenChanged,
-                                            frameEncodingTime,
-                                            frameRenderingTime});
+    observer.onDidFinishRenderingFrame(
+        {MapObserver::RenderMode(renderMode), needsRepaint, placemenChanged, frameEncodingTime, frameRenderingTime});
 
+    if (mode == MapMode::Continuous) {
         if (needsRepaint || transform.inTransition()) {
             onUpdate();
         } else if (rendererFullyLoaded) {