123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408 |
- /*
- * Copyright (C) 2016 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 <utils/StrongPointer.h>
- #include <utils/RefBase.h>
- #include <thread>
- #include <atomic>
- #include <sched.h>
- #include <errno.h>
- // Enhanced version of StrongPointer_test, but using RefBase underneath.
- using namespace android;
- static constexpr int NITERS = 1000000;
- static constexpr int INITIAL_STRONG_VALUE = 1 << 28; // Mirroring RefBase definition.
- class Foo : public RefBase {
- public:
- Foo(bool* deleted_check) : mDeleted(deleted_check) {
- *mDeleted = false;
- }
- ~Foo() {
- *mDeleted = true;
- }
- private:
- bool* mDeleted;
- };
- // A version of Foo that ensures that all objects are allocated at the same
- // address. No more than one can be allocated at a time. Thread-hostile.
- class FooFixedAlloc : public RefBase {
- public:
- static void* operator new(size_t size) {
- if (mAllocCount != 0) {
- abort();
- }
- mAllocCount = 1;
- if (theMemory == nullptr) {
- theMemory = malloc(size);
- }
- return theMemory;
- }
- static void operator delete(void *p) {
- if (mAllocCount != 1 || p != theMemory) {
- abort();
- }
- mAllocCount = 0;
- }
- FooFixedAlloc(bool* deleted_check) : mDeleted(deleted_check) {
- *mDeleted = false;
- }
- ~FooFixedAlloc() {
- *mDeleted = true;
- }
- private:
- bool* mDeleted;
- static int mAllocCount;
- static void* theMemory;
- };
- int FooFixedAlloc::mAllocCount(0);
- void* FooFixedAlloc::theMemory(nullptr);
- TEST(RefBase, StrongMoves) {
- bool isDeleted;
- Foo* foo = new Foo(&isDeleted);
- ASSERT_EQ(INITIAL_STRONG_VALUE, foo->getStrongCount());
- ASSERT_FALSE(isDeleted) << "Already deleted...?";
- sp<Foo> sp1(foo);
- wp<Foo> wp1(sp1);
- ASSERT_EQ(1, foo->getStrongCount());
- // Weak count includes both strong and weak references.
- ASSERT_EQ(2, foo->getWeakRefs()->getWeakCount());
- {
- sp<Foo> sp2 = std::move(sp1);
- ASSERT_EQ(1, foo->getStrongCount())
- << "std::move failed, incremented refcnt";
- ASSERT_EQ(nullptr, sp1.get()) << "std::move failed, sp1 is still valid";
- // The strong count isn't increasing, let's double check the old object
- // is properly reset and doesn't early delete
- sp1 = std::move(sp2);
- }
- ASSERT_FALSE(isDeleted) << "deleted too early! still has a reference!";
- {
- // Now let's double check it deletes on time
- sp<Foo> sp2 = std::move(sp1);
- }
- ASSERT_TRUE(isDeleted) << "foo was leaked!";
- ASSERT_TRUE(wp1.promote().get() == nullptr);
- }
- TEST(RefBase, WeakCopies) {
- bool isDeleted;
- Foo* foo = new Foo(&isDeleted);
- EXPECT_EQ(0, foo->getWeakRefs()->getWeakCount());
- ASSERT_FALSE(isDeleted) << "Foo (weak) already deleted...?";
- wp<Foo> wp1(foo);
- EXPECT_EQ(1, foo->getWeakRefs()->getWeakCount());
- {
- wp<Foo> wp2 = wp1;
- ASSERT_EQ(2, foo->getWeakRefs()->getWeakCount());
- }
- EXPECT_EQ(1, foo->getWeakRefs()->getWeakCount());
- ASSERT_FALSE(isDeleted) << "deleted too early! still has a reference!";
- wp1 = nullptr;
- ASSERT_FALSE(isDeleted) << "Deletion on wp destruction should no longer occur";
- }
- TEST(RefBase, Comparisons) {
- bool isDeleted, isDeleted2, isDeleted3;
- Foo* foo = new Foo(&isDeleted);
- Foo* foo2 = new Foo(&isDeleted2);
- sp<Foo> sp1(foo);
- sp<Foo> sp2(foo2);
- wp<Foo> wp1(sp1);
- wp<Foo> wp2(sp1);
- wp<Foo> wp3(sp2);
- ASSERT_TRUE(wp1 == wp2);
- ASSERT_TRUE(wp1 == sp1);
- ASSERT_TRUE(wp3 == sp2);
- ASSERT_TRUE(wp1 != sp2);
- ASSERT_TRUE(wp1 <= wp2);
- ASSERT_TRUE(wp1 >= wp2);
- ASSERT_FALSE(wp1 != wp2);
- ASSERT_FALSE(wp1 > wp2);
- ASSERT_FALSE(wp1 < wp2);
- ASSERT_FALSE(sp1 == sp2);
- ASSERT_TRUE(sp1 != sp2);
- bool sp1_smaller = sp1 < sp2;
- wp<Foo>wp_smaller = sp1_smaller ? wp1 : wp3;
- wp<Foo>wp_larger = sp1_smaller ? wp3 : wp1;
- ASSERT_TRUE(wp_smaller < wp_larger);
- ASSERT_TRUE(wp_smaller != wp_larger);
- ASSERT_TRUE(wp_smaller <= wp_larger);
- ASSERT_FALSE(wp_smaller == wp_larger);
- ASSERT_FALSE(wp_smaller > wp_larger);
- ASSERT_FALSE(wp_smaller >= wp_larger);
- sp2 = nullptr;
- ASSERT_TRUE(isDeleted2);
- ASSERT_FALSE(isDeleted);
- ASSERT_FALSE(wp3 == sp2);
- // Comparison results on weak pointers should not be affected.
- ASSERT_TRUE(wp_smaller < wp_larger);
- ASSERT_TRUE(wp_smaller != wp_larger);
- ASSERT_TRUE(wp_smaller <= wp_larger);
- ASSERT_FALSE(wp_smaller == wp_larger);
- ASSERT_FALSE(wp_smaller > wp_larger);
- ASSERT_FALSE(wp_smaller >= wp_larger);
- wp2 = nullptr;
- ASSERT_FALSE(wp1 == wp2);
- ASSERT_TRUE(wp1 != wp2);
- wp1.clear();
- ASSERT_TRUE(wp1 == wp2);
- ASSERT_FALSE(wp1 != wp2);
- wp3.clear();
- ASSERT_TRUE(wp1 == wp3);
- ASSERT_FALSE(wp1 != wp3);
- ASSERT_FALSE(isDeleted);
- sp1.clear();
- ASSERT_TRUE(isDeleted);
- ASSERT_TRUE(sp1 == sp2);
- // Try to check that null pointers are properly initialized.
- {
- // Try once with non-null, to maximize chances of getting junk on the
- // stack.
- sp<Foo> sp3(new Foo(&isDeleted3));
- wp<Foo> wp4(sp3);
- wp<Foo> wp5;
- ASSERT_FALSE(wp4 == wp5);
- ASSERT_TRUE(wp4 != wp5);
- ASSERT_FALSE(sp3 == wp5);
- ASSERT_FALSE(wp5 == sp3);
- ASSERT_TRUE(sp3 != wp5);
- ASSERT_TRUE(wp5 != sp3);
- ASSERT_TRUE(sp3 == wp4);
- }
- {
- sp<Foo> sp3;
- wp<Foo> wp4(sp3);
- wp<Foo> wp5;
- ASSERT_TRUE(wp4 == wp5);
- ASSERT_FALSE(wp4 != wp5);
- ASSERT_TRUE(sp3 == wp5);
- ASSERT_TRUE(wp5 == sp3);
- ASSERT_FALSE(sp3 != wp5);
- ASSERT_FALSE(wp5 != sp3);
- ASSERT_TRUE(sp3 == wp4);
- }
- }
- // Check whether comparison against dead wp works, even if the object referenced
- // by the new wp happens to be at the same address.
- TEST(RefBase, ReplacedComparison) {
- bool isDeleted, isDeleted2;
- FooFixedAlloc* foo = new FooFixedAlloc(&isDeleted);
- sp<FooFixedAlloc> sp1(foo);
- wp<FooFixedAlloc> wp1(sp1);
- ASSERT_TRUE(wp1 == sp1);
- sp1.clear(); // Deallocates the object.
- ASSERT_TRUE(isDeleted);
- FooFixedAlloc* foo2 = new FooFixedAlloc(&isDeleted2);
- ASSERT_FALSE(isDeleted2);
- ASSERT_EQ(foo, foo2); // Not technically a legal comparison, but ...
- sp<FooFixedAlloc> sp2(foo2);
- wp<FooFixedAlloc> wp2(sp2);
- ASSERT_TRUE(sp2 == wp2);
- ASSERT_FALSE(sp2 != wp2);
- ASSERT_TRUE(sp2 != wp1);
- ASSERT_FALSE(sp2 == wp1);
- ASSERT_FALSE(sp2 == sp1); // sp1 is null.
- ASSERT_FALSE(wp1 == wp2); // wp1 refers to old object.
- ASSERT_TRUE(wp1 != wp2);
- ASSERT_TRUE(wp1 > wp2 || wp1 < wp2);
- ASSERT_TRUE(wp1 >= wp2 || wp1 <= wp2);
- ASSERT_FALSE(wp1 >= wp2 && wp1 <= wp2);
- ASSERT_FALSE(wp1 == nullptr);
- wp1 = sp2;
- ASSERT_TRUE(wp1 == wp2);
- ASSERT_FALSE(wp1 != wp2);
- }
- // Set up a situation in which we race with visit2AndRremove() to delete
- // 2 strong references. Bar destructor checks that there are no early
- // deletions and prior updates are visible to destructor.
- class Bar : public RefBase {
- public:
- Bar(std::atomic<int>* delete_count) : mVisited1(false), mVisited2(false),
- mDeleteCount(delete_count) {
- }
- ~Bar() {
- EXPECT_TRUE(mVisited1);
- EXPECT_TRUE(mVisited2);
- (*mDeleteCount)++;
- }
- bool mVisited1;
- bool mVisited2;
- private:
- std::atomic<int>* mDeleteCount;
- };
- static sp<Bar> buffer;
- static std::atomic<bool> bufferFull(false);
- // Wait until bufferFull has value val.
- static inline void waitFor(bool val) {
- while (bufferFull != val) {}
- }
- cpu_set_t otherCpus;
- // Divide the cpus we're allowed to run on into myCpus and otherCpus.
- // Set origCpus to the processors we were originally allowed to run on.
- // Return false if origCpus doesn't include at least processors 0 and 1.
- static bool setExclusiveCpus(cpu_set_t* origCpus /* out */,
- cpu_set_t* myCpus /* out */, cpu_set_t* otherCpus) {
- if (sched_getaffinity(0, sizeof(cpu_set_t), origCpus) != 0) {
- return false;
- }
- if (!CPU_ISSET(0, origCpus) || !CPU_ISSET(1, origCpus)) {
- return false;
- }
- CPU_ZERO(myCpus);
- CPU_ZERO(otherCpus);
- CPU_OR(myCpus, myCpus, origCpus);
- CPU_OR(otherCpus, otherCpus, origCpus);
- for (unsigned i = 0; i < CPU_SETSIZE; ++i) {
- // I get the even cores, the other thread gets the odd ones.
- if (i & 1) {
- CPU_CLR(i, myCpus);
- } else {
- CPU_CLR(i, otherCpus);
- }
- }
- return true;
- }
- static void visit2AndRemove() {
- if (sched_setaffinity(0, sizeof(cpu_set_t), &otherCpus) != 0) {
- FAIL() << "setaffinity returned:" << errno;
- }
- for (int i = 0; i < NITERS; ++i) {
- waitFor(true);
- buffer->mVisited2 = true;
- buffer = nullptr;
- bufferFull = false;
- }
- }
- TEST(RefBase, RacingDestructors) {
- cpu_set_t origCpus;
- cpu_set_t myCpus;
- // Restrict us and the helper thread to disjoint cpu sets.
- // This prevents us from getting scheduled against each other,
- // which would be atrociously slow.
- if (setExclusiveCpus(&origCpus, &myCpus, &otherCpus)) {
- std::thread t(visit2AndRemove);
- std::atomic<int> deleteCount(0);
- if (sched_setaffinity(0, sizeof(cpu_set_t), &myCpus) != 0) {
- FAIL() << "setaffinity returned:" << errno;
- }
- for (int i = 0; i < NITERS; ++i) {
- waitFor(false);
- Bar* bar = new Bar(&deleteCount);
- sp<Bar> sp3(bar);
- buffer = sp3;
- bufferFull = true;
- ASSERT_TRUE(bar->getStrongCount() >= 1);
- // Weak count includes strong count.
- ASSERT_TRUE(bar->getWeakRefs()->getWeakCount() >= 1);
- sp3->mVisited1 = true;
- sp3 = nullptr;
- }
- t.join();
- if (sched_setaffinity(0, sizeof(cpu_set_t), &origCpus) != 0) {
- FAIL();
- }
- ASSERT_EQ(NITERS, deleteCount) << "Deletions missed!";
- } // Otherwise this is slow and probably pointless on a uniprocessor.
- }
- static wp<Bar> wpBuffer;
- static std::atomic<bool> wpBufferFull(false);
- // Wait until wpBufferFull has value val.
- static inline void wpWaitFor(bool val) {
- while (wpBufferFull != val) {}
- }
- static void visit3AndRemove() {
- if (sched_setaffinity(0, sizeof(cpu_set_t), &otherCpus) != 0) {
- FAIL() << "setaffinity returned:" << errno;
- }
- for (int i = 0; i < NITERS; ++i) {
- wpWaitFor(true);
- {
- sp<Bar> sp1 = wpBuffer.promote();
- // We implicitly check that sp1 != NULL
- sp1->mVisited2 = true;
- }
- wpBuffer = nullptr;
- wpBufferFull = false;
- }
- }
- TEST(RefBase, RacingPromotions) {
- cpu_set_t origCpus;
- cpu_set_t myCpus;
- // Restrict us and the helper thread to disjoint cpu sets.
- // This prevents us from getting scheduled against each other,
- // which would be atrociously slow.
- if (setExclusiveCpus(&origCpus, &myCpus, &otherCpus)) {
- std::thread t(visit3AndRemove);
- std::atomic<int> deleteCount(0);
- if (sched_setaffinity(0, sizeof(cpu_set_t), &myCpus) != 0) {
- FAIL() << "setaffinity returned:" << errno;
- }
- for (int i = 0; i < NITERS; ++i) {
- Bar* bar = new Bar(&deleteCount);
- wp<Bar> wp1(bar);
- bar->mVisited1 = true;
- if (i % (NITERS / 10) == 0) {
- // Do this rarely, since it generates a log message.
- wp1 = nullptr; // No longer destroys the object.
- wp1 = bar;
- }
- wpBuffer = wp1;
- ASSERT_EQ(bar->getWeakRefs()->getWeakCount(), 2);
- wpBufferFull = true;
- // Promotion races with that in visit3AndRemove.
- // This may or may not succeed, but it shouldn't interfere with
- // the concurrent one.
- sp<Bar> sp1 = wp1.promote();
- wpWaitFor(false); // Waits for other thread to drop strong pointer.
- sp1 = nullptr;
- // No strong pointers here.
- sp1 = wp1.promote();
- ASSERT_EQ(sp1.get(), nullptr) << "Dead wp promotion succeeded!";
- }
- t.join();
- if (sched_setaffinity(0, sizeof(cpu_set_t), &origCpus) != 0) {
- FAIL();
- }
- ASSERT_EQ(NITERS, deleteCount) << "Deletions missed!";
- } // Otherwise this is slow and probably pointless on a uniprocessor.
- }
|