Change the variable name "buffer_state_bit" into "client_state_mask".
Reasons:
1. This variable is not refering to a property of the buffer. It refers
to a client of the buffer.
2. The original "buffer_state_bit" of a producer/consumer is actually
the client state bit mask for both buffer_state and fence_state in
shared memory. Thus, "buffer_state_bit" does not make sense for the
fence state.
3. In the future, Every clients takes up two bits in the buffer_state.
For simpler bit manipulation, there will be a future change making the
client_state_bits two bits as well. Please refer to ag/5236978 for an
early look at the future bit manipulation. Thus, this change replaces
"bit" with "mask".
Test: build
Bug: 112007999
Change-Id: I72f59ab9491bd2f135da068f578195fbf5e6c2b6
diff --git a/libs/vr/libbufferhub/buffer_hub-test.cpp b/libs/vr/libbufferhub/buffer_hub-test.cpp
index 8351efc..3e26dae 100644
--- a/libs/vr/libbufferhub/buffer_hub-test.cpp
+++ b/libs/vr/libbufferhub/buffer_hub-test.cpp
@@ -59,19 +59,19 @@
ASSERT_TRUE(c2.get() != nullptr);
// Producer state mask is unique, i.e. 1.
- EXPECT_EQ(p->buffer_state_bit(), kProducerStateBit);
+ EXPECT_EQ(p->client_state_mask(), kProducerStateBit);
// Consumer state mask cannot have producer bit on.
- EXPECT_EQ(c->buffer_state_bit() & kProducerStateBit, 0U);
+ EXPECT_EQ(c->client_state_mask() & kProducerStateBit, 0U);
// Consumer state mask must be a single, i.e. power of 2.
- EXPECT_NE(c->buffer_state_bit(), 0U);
- EXPECT_EQ(c->buffer_state_bit() & (c->buffer_state_bit() - 1), 0U);
+ EXPECT_NE(c->client_state_mask(), 0U);
+ EXPECT_EQ(c->client_state_mask() & (c->client_state_mask() - 1), 0U);
// Consumer state mask cannot have producer bit on.
- EXPECT_EQ(c2->buffer_state_bit() & kProducerStateBit, 0U);
+ EXPECT_EQ(c2->client_state_mask() & kProducerStateBit, 0U);
// Consumer state mask must be a single, i.e. power of 2.
- EXPECT_NE(c2->buffer_state_bit(), 0U);
- EXPECT_EQ(c2->buffer_state_bit() & (c2->buffer_state_bit() - 1), 0U);
+ EXPECT_NE(c2->client_state_mask(), 0U);
+ EXPECT_EQ(c2->client_state_mask() & (c2->client_state_mask() - 1), 0U);
// Each consumer should have unique bit.
- EXPECT_EQ(c->buffer_state_bit() & c2->buffer_state_bit(), 0U);
+ EXPECT_EQ(c->client_state_mask() & c2->client_state_mask(), 0U);
// Initial state: producer not available, consumers not available.
EXPECT_EQ(0, RETRY_EINTR(p->Poll(kPollTimeoutMs)));
@@ -178,16 +178,16 @@
ASSERT_TRUE(p.get() != nullptr);
// It's ok to create up to kMaxConsumerCount consumer buffers.
- uint64_t buffer_state_bits = p->buffer_state_bit();
+ uint64_t client_state_masks = p->client_state_mask();
std::array<std::unique_ptr<ConsumerBuffer>, kMaxConsumerCount> cs;
for (size_t i = 0; i < kMaxConsumerCount; i++) {
cs[i] = ConsumerBuffer::Import(p->CreateConsumer());
ASSERT_TRUE(cs[i].get() != nullptr);
// Expect all buffers have unique state mask.
- EXPECT_EQ(buffer_state_bits & cs[i]->buffer_state_bit(), 0U);
- buffer_state_bits |= cs[i]->buffer_state_bit();
+ EXPECT_EQ(client_state_masks & cs[i]->client_state_mask(), 0U);
+ client_state_masks |= cs[i]->client_state_mask();
}
- EXPECT_EQ(buffer_state_bits, kProducerStateBit | kConsumerStateMask);
+ EXPECT_EQ(client_state_masks, kProducerStateBit | kConsumerStateMask);
// The 64th creation will fail with out-of-memory error.
auto state = p->CreateConsumer();
@@ -195,14 +195,14 @@
// Release any consumer should allow us to re-create.
for (size_t i = 0; i < kMaxConsumerCount; i++) {
- buffer_state_bits &= ~cs[i]->buffer_state_bit();
+ client_state_masks &= ~cs[i]->client_state_mask();
cs[i] = nullptr;
cs[i] = ConsumerBuffer::Import(p->CreateConsumer());
ASSERT_TRUE(cs[i].get() != nullptr);
// The released state mask will be reused.
- EXPECT_EQ(buffer_state_bits & cs[i]->buffer_state_bit(), 0U);
- buffer_state_bits |= cs[i]->buffer_state_bit();
- EXPECT_EQ(buffer_state_bits, kProducerStateBit | kConsumerStateMask);
+ EXPECT_EQ(client_state_masks & cs[i]->client_state_mask(), 0U);
+ client_state_masks |= cs[i]->client_state_mask();
+ EXPECT_EQ(client_state_masks, kProducerStateBit | kConsumerStateMask);
}
}
@@ -402,7 +402,7 @@
EXPECT_TRUE(IsBufferPosted(p->buffer_state()));
for (size_t i = 0; i < kMaxConsumerCount; i++) {
EXPECT_TRUE(
- IsBufferPosted(cs[i]->buffer_state(), cs[i]->buffer_state_bit()));
+ IsBufferPosted(cs[i]->buffer_state(), cs[i]->client_state_mask()));
EXPECT_LT(0, RETRY_EINTR(cs[i]->Poll(kPollTimeoutMs)));
EXPECT_EQ(0, cs[i]->AcquireAsync(&metadata, &invalid_fence));
EXPECT_TRUE(IsBufferAcquired(p->buffer_state()));
@@ -707,7 +707,7 @@
std::unique_ptr<ConsumerBuffer> c1 =
ConsumerBuffer::Import(p->CreateConsumer());
ASSERT_TRUE(c1.get() != nullptr);
- const uint64_t consumer_state_bit1 = c1->buffer_state_bit();
+ const uint64_t consumer_state_bit1 = c1->client_state_mask();
DvrNativeBufferMetadata meta;
EXPECT_EQ(0, p->PostAsync(&meta, LocalHandle()));
@@ -723,7 +723,7 @@
std::unique_ptr<ConsumerBuffer> c2 =
ConsumerBuffer::Import(p->CreateConsumer());
ASSERT_TRUE(c2.get() != nullptr);
- const uint64_t consumer_state_bit2 = c2->buffer_state_bit();
+ const uint64_t consumer_state_bit2 = c2->client_state_mask();
EXPECT_NE(consumer_state_bit1, consumer_state_bit2);
// The new consumer is available for acquire.
@@ -739,7 +739,7 @@
std::unique_ptr<ConsumerBuffer> c3 =
ConsumerBuffer::Import(p->CreateConsumer());
ASSERT_TRUE(c3.get() != nullptr);
- const uint64_t consumer_state_bit3 = c3->buffer_state_bit();
+ const uint64_t consumer_state_bit3 = c3->client_state_mask();
EXPECT_NE(consumer_state_bit2, consumer_state_bit3);
// The consumer buffer is not acquirable.
EXPECT_GE(0, RETRY_EINTR(c3->Poll(kPollTimeoutMs)));
@@ -911,12 +911,12 @@
// These two buffer instances are based on the same physical buffer under the
// hood, so they should share the same id.
EXPECT_EQ(b1_id, b2_id);
- // We use buffer_state_bit() to tell those two instances apart.
- EXPECT_NE(b1->buffer_state_bit(), b2->buffer_state_bit());
- EXPECT_NE(b1->buffer_state_bit(), 0ULL);
- EXPECT_NE(b2->buffer_state_bit(), 0ULL);
- EXPECT_NE(b1->buffer_state_bit(), kProducerStateBit);
- EXPECT_NE(b2->buffer_state_bit(), kProducerStateBit);
+ // We use client_state_mask() to tell those two instances apart.
+ EXPECT_NE(b1->client_state_mask(), b2->client_state_mask());
+ EXPECT_NE(b1->client_state_mask(), 0ULL);
+ EXPECT_NE(b2->client_state_mask(), 0ULL);
+ EXPECT_NE(b1->client_state_mask(), kProducerStateBit);
+ EXPECT_NE(b2->client_state_mask(), kProducerStateBit);
// Both buffer instances should be in gained state.
EXPECT_TRUE(IsBufferGained(b1->buffer_state()));