libs/hwui/tests/unit/CommonPoolTests.cpp

/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <gtest/gtest.h>

#include "thread/CommonPool.h"

#include <array>
#include <condition_variable>
#include <set>
#include <thread>
#include "unistd.h"

using namespace android;
using namespace android::uirenderer;

TEST(CommonPool, post) {
    std::atomic_bool ran(false);
    CommonPool::post([&ran] { ran = true; });
    for (int i = 0; !ran && i < 1000; i++) {
        usleep(1);
    }
    EXPECT_TRUE(ran) << "Failed to flip atomic after 1 second";
}

// test currently relies on timings, which
// makes it flaky. Disable for now
TEST(DISABLED_CommonPool, threadCount) {
    std::set<pid_t> threads;
    std::array<std::future<pid_t>, 64> futures;
    for (int i = 0; i < futures.size(); i++) {
        futures[i] = CommonPool::async([] {
            usleep(10);
            return gettid();
        });
    }
    for (auto& f : futures) {
        threads.insert(f.get());
    }
    EXPECT_EQ(threads.size(), CommonPool::THREAD_COUNT);
    EXPECT_EQ(0, threads.count(gettid()));
}

TEST(CommonPool, singleThread) {
    std::mutex mutex;
    std::condition_variable fence;
    bool isProcessing = false;
    bool queuedSecond = false;

    auto f1 = CommonPool::async([&] {
        {
            std::unique_lock lock{mutex};
            isProcessing = true;
            fence.notify_all();
            while (!queuedSecond) {
                fence.wait(lock);
            }
        }
        return gettid();
    });

    {
        std::unique_lock lock{mutex};
        while (!isProcessing) {
            fence.wait(lock);
        }
    }

    auto f2 = CommonPool::async([] {
        return gettid();
    });

    {
        std::unique_lock lock{mutex};
        queuedSecond = true;
        fence.notify_all();
    }

    auto tid1 = f1.get();
    auto tid2 = f2.get();
    EXPECT_EQ(tid1, tid2);
    EXPECT_NE(gettid(), tid1);
}

// Test currently relies on timings
// which makes it flaky, disable for now
TEST(DISABLED_CommonPool, fullQueue) {
    std::mutex lock;
    std::condition_variable fence;
    bool signaled = false;
    static constexpr auto QUEUE_COUNT = CommonPool::THREAD_COUNT + CommonPool::QUEUE_SIZE + 10;
    std::atomic_int queuedCount{0};
    std::array<std::future<void>, QUEUE_COUNT> futures;

    std::thread queueThread{[&] {
        for (int i = 0; i < QUEUE_COUNT; i++) {
            futures[i] = CommonPool::async([&] {
                std::unique_lock _lock{lock};
                while (!signaled) {
                    fence.wait(_lock);
                }
            });
            queuedCount++;
        }
    }};

    int previous;
    do {
        previous = queuedCount.load();
        usleep(10000);
    } while (previous != queuedCount.load());

    EXPECT_GT(queuedCount.load(), CommonPool::QUEUE_SIZE);
    EXPECT_LT(queuedCount.load(), QUEUE_COUNT);

    {
        std::unique_lock _lock{lock};
        signaled = true;
        fence.notify_all();
    }

    queueThread.join();
    EXPECT_EQ(queuedCount.load(), QUEUE_COUNT);

    // Ensure all our tasks are finished before return as they have references to the stack
    for (auto& f : futures) {
        f.get();
    }
}

class ObjectTracker {
    static std::atomic_int sGlobalCount;

public:
    ObjectTracker() {
        sGlobalCount++;
    }
    ObjectTracker(const ObjectTracker&) {
        sGlobalCount++;
    }
    ObjectTracker(ObjectTracker&&) {
        sGlobalCount++;
    }
    ~ObjectTracker() {
        sGlobalCount--;
    }

    static int count() { return sGlobalCount.load(); }
};

std::atomic_int ObjectTracker::sGlobalCount{0};

TEST(CommonPool, asyncLifecycleCheck) {
    ASSERT_EQ(0, ObjectTracker::count());
    {
        ObjectTracker obj;
        ASSERT_EQ(1, ObjectTracker::count());
        EXPECT_LT(1, CommonPool::async([obj] { return ObjectTracker::count(); }).get());
    }
    CommonPool::waitForIdle();
    ASSERT_EQ(0, ObjectTracker::count());
}

TEST(CommonPool, syncLifecycleCheck) {
    ASSERT_EQ(0, ObjectTracker::count());
    {
        ObjectTracker obj;
        ASSERT_EQ(1, ObjectTracker::count());
        EXPECT_LT(1, CommonPool::runSync([obj] { return ObjectTracker::count(); }));
    }
    CommonPool::waitForIdle();
    ASSERT_EQ(0, ObjectTracker::count());
}