Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7e204b72 authored by Tianyu Jiang's avatar Tianyu Jiang
Browse files

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
parent 73a96151

libs/ui/BufferHubBuffer.cpp

+1 −1
Original line number Diff line number Diff line
@@ -159,7 +159,7 @@ int BufferHubBuffer::ImportGraphicBuffer() { 


    // If all imports succeed, replace the previous buffer and id.

    mId = bufferId;

    mBufferStateBit = bufferTraits.buffer_state_bit();

    mClientStateMask = bufferTraits.client_state_mask();



    // TODO(b/112012161) Set up shared fences.

    ALOGD("BufferHubBuffer::ImportGraphicBuffer: id=%d, buffer_state=%" PRIx64 ".", id(),

libs/ui/include/ui/BufferHubBuffer.h

+2 −2
Original line number Diff line number Diff line
@@ -88,7 +88,7 @@ public: 


    // A state mask which is unique to a buffer hub client among all its siblings sharing the same

    // concrete graphic buffer.

    uint64_t buffer_state_bit() const { return mBufferStateBit; }

    uint64_t client_state_mask() const { return mClientStateMask; }



    size_t user_metadata_size() const { return mMetadata.user_metadata_size(); }
@@ -126,7 +126,7 @@ private: 


    // Global id for the buffer that is consistent across processes.

    int mId = -1;

    uint64_t mBufferStateBit = 0;

    uint64_t mClientStateMask = 0;



    // Wrapps the gralloc buffer handle of this buffer.

    dvr::NativeHandleWrapper<pdx::LocalHandle> mBufferHandle;

libs/ui/tests/BufferHubBuffer_test.cpp

+6 −6
Original line number Diff line number Diff line
@@ -100,12 +100,12 @@ TEST_F(BufferHubBufferTest, DuplicateBufferHubBuffer) { 
    // These two buffer instances are based on the same physical buffer under the

    // hood, so they should share the same id.

    EXPECT_EQ(id1, id2);

    // 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()));

libs/vr/libbufferhub/buffer_hub-test.cpp

+26 −26
Original line number Diff line number Diff line
@@ -59,19 +59,19 @@ TEST_F(LibBufferHubTest, TestBasicUsage) { 
  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 @@ TEST_F(LibBufferHubTest, TestStateMask) { 
  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 @@ TEST_F(LibBufferHubTest, TestStateMask) { 


  // 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 @@ TEST_F(LibBufferHubTest, TestMaxConsumers) { 
  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 @@ TEST_F(LibBufferHubTest, TestOrphanedAcquire) { 
  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 @@ TEST_F(LibBufferHubTest, TestOrphanedAcquire) { 
  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 @@ TEST_F(LibBufferHubTest, TestOrphanedAcquire) { 
  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 @@ TEST_F(LibBufferHubTest, TestDuplicateBufferHubBuffer) { 
  // 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()));

libs/vr/libbufferhub/buffer_hub_base.cpp

+4 −4
Original line number Diff line number Diff line
@@ -114,7 +114,7 @@ int BufferHubBase::ImportBuffer() { 


  id_ = new_id;

  cid_ = buffer_desc.buffer_cid();

  buffer_state_bit_ = buffer_desc.buffer_state_bit();

  client_state_mask_ = buffer_desc.client_state_mask();



  // Note that here the buffer_state, fence_state and active_clients_bit_mask

  // are mapped from shared memory as an atomic object. The std::atomic's
@@ -169,7 +169,7 @@ int BufferHubBase::UpdateSharedFence(const LocalHandle& new_fence, 
      // If ready fence is valid, we put that into the epoll set.

      epoll_event event;

      event.events = EPOLLIN;

      event.data.u64 = buffer_state_bit();

      event.data.u64 = client_state_mask();

      pending_fence_fd_ = new_fence.Duplicate();

      if (epoll_ctl(shared_fence.Get(), EPOLL_CTL_ADD, pending_fence_fd_.Get(),

                    &event) < 0) {
@@ -182,12 +182,12 @@ int BufferHubBase::UpdateSharedFence(const LocalHandle& new_fence, 
      }

      // Set bit in fence state to indicate that there is a fence from this

      // producer or consumer.

      fence_state_->fetch_or(buffer_state_bit());

      fence_state_->fetch_or(client_state_mask());

    } else {

      // Unset bit in fence state to indicate that there is no fence, so that

      // when consumer to acquire or producer to acquire, it knows no need to

      // check fence for this buffer.

      fence_state_->fetch_and(~buffer_state_bit());

      fence_state_->fetch_and(~client_state_mask());

    }

  }