kc3-lang/angle/src/libANGLE/WorkerThread_unittest.cpp

• Show log

  Commit

• Hash : 01074255
  Author :
  Date : 2016-11-28T15:55:51
  

  D3D: Implement multi-thread shader compilation.
  
  Choose to use std::async for now to implement multi-threaded compiles.
  This should work across platforms and also be usable for other
  threading tasks. Note that std::async does not have a good way to
  wait for multiple std::futures. Also the Linux compile of std::async
  is broken due to a bug in an old STL version, so disable it on this
  platform.
  
  The implementation uses a static polymorphism approach, which should
  have very good performance (no virtual calls).
  
  This design leaves the door open for other future implementations,
  such as a Win32 thread pool, or one based on angle::Platform.
  
  BUG=angleproject:422
  
  Change-Id: Ia2f13c3af0339efaca1d19b40b3e08ecca61b8e8
  Reviewed-on: https://chromium-review.googlesource.com/413712
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/WorkerThread_unittest.cpp

• //
  // Copyright 2016 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // WorkerThread_unittest:
  //   Simple tests for the worker thread class.
  
  #include <array>
  #include <gtest/gtest.h>
  
  #include "libANGLE/WorkerThread.h"
  
  using namespace angle;
  
  namespace
  {
  
  template <typename T>
  class WorkerPoolTest : public ::testing::Test
  {
    public:
      T workerPool = {4};
  };
  
  #if (ANGLE_STD_ASYNC_WORKERS == ANGLE_ENABLED)
  using WorkerPoolTypes = ::testing::Types<priv::AsyncWorkerPool, priv::SingleThreadedWorkerPool>;
  #else
  using WorkerPoolTypes = ::testing::Types<priv::SingleThreadedWorkerPool>;
  #endif  // (ANGLE_STD_ASYNC_WORKERS == ANGLE_ENABLED)
  
  TYPED_TEST_CASE(WorkerPoolTest, WorkerPoolTypes);
  
  // Tests simple worker pool application.
  TYPED_TEST(WorkerPoolTest, SimpleTask)
  {
      class TestTask : public Closure
      {
        public:
          void operator()() override { fired = true; }
  
          bool fired = false;
      };
  
      std::array<TestTask, 4> tasks;
      std::array<typename TypeParam::WaitableEventType, 4> waitables = {{
          this->workerPool.postWorkerTask(&tasks[0]), this->workerPool.postWorkerTask(&tasks[1]),
          this->workerPool.postWorkerTask(&tasks[2]), this->workerPool.postWorkerTask(&tasks[3]),
      }};
  
      TypeParam::WaitableEventType::WaitMany(&waitables);
  
      for (const auto &task : tasks)
      {
          EXPECT_TRUE(task.fired);
      }
  }
  
  }  // anonymous namespace
  

Download