Add Chromium's StackVector base class and ityp::stack_vec

In order to lift Dawn's restriction on the number of bindings
per bind group, static sized arays need to be converted to
dynamically sized vectors. This CL adds Chromium's StackVector
class which behaves like std::vector but provides a stack allocator
to allocate small vectors on the stack. Dawn can use this to avoid
making separate heap allocations for a smaller, realistic binding
counts.

The CL also adds an ityp::stack_vec class to support using
a StackVector with TypedInteger indices.

Bug: dawn:442, dawn:443
Change-Id: I7604c02b3ea52cd63990a2e8b45ed238a5d52232
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/23681
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Bryan Bernhart <bryan.bernhart@intel.com>
Reviewed-by: Austin Eng <enga@chromium.org>
Commit-Queue: Austin Eng <enga@chromium.org>

src/tests/BUILD.gn

@@ -173,6 +173,7 @@ test("dawn_unittests") {
     "unittests/SerialMapTests.cpp",
     "unittests/SerialQueueTests.cpp",
     "unittests/SlabAllocatorTests.cpp",
+    "unittests/StackContainerTests.cpp",
     "unittests/SystemUtilsTests.cpp",
     "unittests/ToBackendTests.cpp",
     "unittests/TypedIntegerTests.cpp",

src/tests/unittests/StackContainerTests.cpp

@@ -0,0 +1,171 @@
+// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file is a modified copy of Chromium's /src/base/containers/stack_container_unittest.cc
+
+#include <gtest/gtest.h>
+
+#define UNIT_TEST
+
+#include "common/RefCounted.h"
+#include "common/StackContainer.h"
+
+#include <algorithm>
+#include <cstddef>
+
+namespace {
+
+    class Dummy : public RefCounted {
+      public:
+        explicit Dummy(int* alive) : mAlive(alive) {
+            ++*mAlive;
+        }
+
+      private:
+        ~Dummy() {
+            --*mAlive;
+        }
+
+        int* const mAlive;
+    };
+
+}  // namespace
+
+TEST(StackContainer, Vector) {
+    const int stack_size = 3;
+    StackVector<int, stack_size> vect;
+    const int* stack_buffer = &vect.stack_data().stack_buffer()[0];
+
+    // The initial |stack_size| elements should appear in the stack buffer.
+    EXPECT_EQ(static_cast<size_t>(stack_size), vect.container().capacity());
+    for (int i = 0; i < stack_size; i++) {
+        vect.container().push_back(i);
+        EXPECT_EQ(stack_buffer, &vect.container()[0]);
+        EXPECT_TRUE(vect.stack_data().used_stack_buffer_);
+    }
+
+    // Adding more elements should push the array onto the heap.
+    for (int i = 0; i < stack_size; i++) {
+        vect.container().push_back(i + stack_size);
+        EXPECT_NE(stack_buffer, &vect.container()[0]);
+        EXPECT_FALSE(vect.stack_data().used_stack_buffer_);
+    }
+
+    // The array should still be in order.
+    for (int i = 0; i < stack_size * 2; i++)
+        EXPECT_EQ(i, vect.container()[i]);
+
+    // Resize to smaller. Our STL implementation won't reallocate in this case,
+    // otherwise it might use our stack buffer. We reserve right after the resize
+    // to guarantee it isn't using the stack buffer, even though it doesn't have
+    // much data.
+    vect.container().resize(stack_size);
+    vect.container().reserve(stack_size * 2);
+    EXPECT_FALSE(vect.stack_data().used_stack_buffer_);
+
+    // Copying the small vector to another should use the same allocator and use
+    // the now-unused stack buffer. GENERALLY CALLERS SHOULD NOT DO THIS since
+    // they have to get the template types just right and it can cause errors.
+    std::vector<int, StackAllocator<int, stack_size>> other(vect.container());
+    EXPECT_EQ(stack_buffer, &other.front());
+    EXPECT_TRUE(vect.stack_data().used_stack_buffer_);
+    for (int i = 0; i < stack_size; i++)
+        EXPECT_EQ(i, other[i]);
+}
+
+TEST(StackContainer, VectorDoubleDelete) {
+    // Regression testing for double-delete.
+    typedef StackVector<Ref<Dummy>, 2> Vector;
+    Vector vect;
+
+    int alive = 0;
+    Ref<Dummy> dummy = AcquireRef(new Dummy(&alive));
+    EXPECT_EQ(alive, 1);
+
+    vect->push_back(dummy);
+    EXPECT_EQ(alive, 1);
+
+    Dummy* dummy_unref = dummy.Get();
+    dummy = nullptr;
+    EXPECT_EQ(alive, 1);
+
+    auto itr = std::find(vect->begin(), vect->end(), dummy_unref);
+    EXPECT_EQ(itr->Get(), dummy_unref);
+    vect->erase(itr);
+    EXPECT_EQ(alive, 0);
+
+    // Shouldn't crash at exit.
+}
+
+namespace {
+
+    template <size_t alignment>
+    class AlignedData {
+      public:
+        AlignedData() {
+            memset(data_, 0, alignment);
+        }
+        ~AlignedData() = default;
+        alignas(alignment) char data_[alignment];
+    };
+
+}  // anonymous namespace
+
+#define EXPECT_ALIGNED(ptr, align) EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(ptr) & (align - 1))
+
+TEST(StackContainer, BufferAlignment) {
+    StackVector<wchar_t, 16> text;
+    text->push_back(L'A');
+    EXPECT_ALIGNED(&text[0], alignof(wchar_t));
+
+    StackVector<double, 1> doubles;
+    doubles->push_back(0.0);
+    EXPECT_ALIGNED(&doubles[0], alignof(double));
+
+    StackVector<AlignedData<16>, 1> aligned16;
+    aligned16->push_back(AlignedData<16>());
+    EXPECT_ALIGNED(&aligned16[0], 16);
+
+#if !defined(DAWN_COMPILER_GCC) || defined(__x86_64__) || defined(__i386__)
+    // It seems that non-X86 gcc doesn't respect greater than 16 byte alignment.
+    // See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=33721 for details.
+    // TODO(sbc):re-enable this if GCC starts respecting higher alignments.
+    StackVector<AlignedData<256>, 1> aligned256;
+    aligned256->push_back(AlignedData<256>());
+    EXPECT_ALIGNED(&aligned256[0], 256);
+#endif
+}
+
+template class StackVector<int, 2>;
+template class StackVector<Ref<Dummy>, 2>;
+
+template <typename T, size_t size>
+void CheckStackVectorElements(const StackVector<T, size>& vec, std::initializer_list<T> expected) {
+    auto expected_it = expected.begin();
+    EXPECT_EQ(vec->size(), expected.size());
+    for (T t : vec) {
+        EXPECT_NE(expected.end(), expected_it);
+        EXPECT_EQ(*expected_it, t);
+        ++expected_it;
+    }
+    EXPECT_EQ(expected.end(), expected_it);
+}
+
+TEST(StackContainer, Iteration) {
+    StackVector<int, 3> vect;
+    vect->push_back(7);
+    vect->push_back(11);
+
+    CheckStackVectorElements(vect, {7, 11});
+    for (int& i : vect) {
+        ++i;
+    }
+    CheckStackVectorElements(vect, {8, 12});
+    vect->push_back(13);
+    CheckStackVectorElements(vect, {8, 12, 13});
+    vect->resize(5);
+    CheckStackVectorElements(vect, {8, 12, 13, 0, 0});
+    vect->resize(1);
+    CheckStackVectorElements(vect, {8});
+}