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

Commit e4108256 authored by Jiwen Cai's avatar Jiwen Cai Committed by Android (Google) Code Review
Browse files

Merge "Simplify ProducerQueue::Create"

parents 5c865e5d cbd32bfd

libs/vr/libbufferhub/include/private/dvr/bufferhub_rpc.h

+13 −6
Original line number Diff line number Diff line
@@ -129,19 +129,26 @@ class FenceHandle { 
using LocalFence = FenceHandle<pdx::LocalHandle>;

using BorrowedFence = FenceHandle<pdx::BorrowedHandle>;



struct QueueInfo {

struct ProducerQueueConfig {

  size_t meta_size_bytes;



 private:

  PDX_SERIALIZABLE_MEMBERS(ProducerQueueConfig, meta_size_bytes);

};



struct QueueInfo {

  ProducerQueueConfig producer_config;

  int id;



 private:

  PDX_SERIALIZABLE_MEMBERS(QueueInfo, meta_size_bytes, id);

  PDX_SERIALIZABLE_MEMBERS(QueueInfo, producer_config, id);

};



struct UsagePolicy {

  uint64_t usage_set_mask;

  uint64_t usage_clear_mask;

  uint64_t usage_deny_set_mask;

  uint64_t usage_deny_clear_mask;

  uint64_t usage_set_mask{0};

  uint64_t usage_clear_mask{0};

  uint64_t usage_deny_set_mask{0};

  uint64_t usage_deny_clear_mask{0};



 private:

  PDX_SERIALIZABLE_MEMBERS(UsagePolicy, usage_set_mask, usage_clear_mask,

libs/vr/libbufferhubqueue/buffer_hub_queue_client.cpp

+5 −13
Original line number Diff line number Diff line
@@ -10,7 +10,6 @@ 
#include <pdx/default_transport/client_channel.h>

#include <pdx/default_transport/client_channel_factory.h>

#include <pdx/file_handle.h>

#include <private/dvr/bufferhub_rpc.h>



#define RETRY_EINTR(fnc_call)                 \

  ([&]() -> decltype(fnc_call) {              \
@@ -106,7 +105,7 @@ Status<void> BufferHubQueue::ImportQueue() { 
          status.GetErrorMessage().c_str());

    return ErrorStatus(status.error());

  } else {

    SetupQueue(status.get().meta_size_bytes, status.get().id);

    SetupQueue(status.get().producer_config.meta_size_bytes, status.get().id);

    return {};

  }

}
@@ -396,9 +395,6 @@ Status<std::shared_ptr<BufferHubBuffer>> BufferHubQueue::Dequeue( 
  return {std::move(buffer)};

}



ProducerQueue::ProducerQueue(size_t meta_size)

    : ProducerQueue(meta_size, 0, 0, 0, 0) {}



ProducerQueue::ProducerQueue(LocalChannelHandle handle)

    : BASE(std::move(handle)) {

  auto status = ImportQueue();
@@ -409,14 +405,10 @@ ProducerQueue::ProducerQueue(LocalChannelHandle handle) 
  }

}



ProducerQueue::ProducerQueue(size_t meta_size, uint64_t usage_set_mask,

                             uint64_t usage_clear_mask,

                             uint64_t usage_deny_set_mask,

                             uint64_t usage_deny_clear_mask)

ProducerQueue::ProducerQueue(size_t meta_size, const UsagePolicy& usage)

    : BASE(BufferHubRPC::kClientPath) {

  auto status = InvokeRemoteMethod<BufferHubRPC::CreateProducerQueue>(

      meta_size, UsagePolicy{usage_set_mask, usage_clear_mask,

                             usage_deny_set_mask, usage_deny_clear_mask});

  auto status =

      InvokeRemoteMethod<BufferHubRPC::CreateProducerQueue>(meta_size, usage);

  if (!status) {

    ALOGE("ProducerQueue::ProducerQueue: Failed to create producer queue: %s",

          status.GetErrorMessage().c_str());
@@ -424,7 +416,7 @@ ProducerQueue::ProducerQueue(size_t meta_size, uint64_t usage_set_mask, 
    return;

  }



  SetupQueue(status.get().meta_size_bytes, status.get().id);

  SetupQueue(status.get().producer_config.meta_size_bytes, status.get().id);

}



Status<void> ProducerQueue::AllocateBuffer(uint32_t width, uint32_t height,

libs/vr/libbufferhubqueue/buffer_hub_queue_producer.cpp

+2 −1
Original line number Diff line number Diff line
@@ -11,7 +11,8 @@ namespace dvr { 
/* static */

sp<BufferHubQueueProducer> BufferHubQueueProducer::Create() {

  sp<BufferHubQueueProducer> producer = new BufferHubQueueProducer;

  producer->queue_ = ProducerQueue::Create<DvrNativeBufferMetadata>();

  producer->queue_ =

      ProducerQueue::Create<DvrNativeBufferMetadata>(UsagePolicy{});

  return producer;

}

libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_client.h

+8 −32
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ 


#include <pdx/client.h>

#include <pdx/status.h>

#include <private/dvr/bufferhub_rpc.h>

#include <private/dvr/buffer_hub_client.h>

#include <private/dvr/epoll_file_descriptor.h>

#include <private/dvr/ring_buffer.h>
@@ -222,14 +223,6 @@ class BufferHubQueue : public pdx::Client { 


class ProducerQueue : public pdx::ClientBase<ProducerQueue, BufferHubQueue> {

 public:

  template <typename Meta>

  static std::unique_ptr<ProducerQueue> Create() {

    return BASE::Create(sizeof(Meta));

  }

  static std::unique_ptr<ProducerQueue> Create(size_t meta_size_bytes) {

    return BASE::Create(meta_size_bytes);

  }



  // Usage bits in |usage_set_mask| will be automatically masked on. Usage bits

  // in |usage_clear_mask| will be automatically masked off. Note that

  // |usage_set_mask| and |usage_clear_mask| may conflict with each other, but
@@ -242,20 +235,12 @@ class ProducerQueue : public pdx::ClientBase<ProducerQueue, BufferHubQueue> { 
  // |usage_deny_clear_mask| shall not conflict with each other. Such

  // configuration will be treated as invalid input on creation.

  template <typename Meta>

  static std::unique_ptr<ProducerQueue> Create(uint32_t usage_set_mask,

                                               uint32_t usage_clear_mask,

                                               uint32_t usage_deny_set_mask,

                                               uint32_t usage_deny_clear_mask) {

    return BASE::Create(sizeof(Meta), usage_set_mask, usage_clear_mask,

                        usage_deny_set_mask, usage_deny_clear_mask);

  static std::unique_ptr<ProducerQueue> Create(const UsagePolicy& usage) {

    return BASE::Create(sizeof(Meta), usage);

  }

  static std::unique_ptr<ProducerQueue> Create(size_t meta_size_bytes,

                                               uint32_t usage_set_mask,

                                               uint32_t usage_clear_mask,

                                               uint32_t usage_deny_set_mask,

                                               uint32_t usage_deny_clear_mask) {

    return BASE::Create(meta_size_bytes, usage_set_mask, usage_clear_mask,

                        usage_deny_set_mask, usage_deny_clear_mask);

                                               const UsagePolicy& usage) {

    return BASE::Create(meta_size_bytes, usage);

  }



  // Import a ProducerQueue from a channel handle.
@@ -305,11 +290,8 @@ class ProducerQueue : public pdx::ClientBase<ProducerQueue, BufferHubQueue> { 
  // Constructors are automatically exposed through ProducerQueue::Create(...)

  // static template methods inherited from ClientBase, which take the same

  // arguments as the constructors.

  explicit ProducerQueue(size_t meta_size);

  explicit ProducerQueue(pdx::LocalChannelHandle handle);

  ProducerQueue(size_t meta_size, uint64_t usage_set_mask,

                uint64_t usage_clear_mask, uint64_t usage_deny_set_mask,

                uint64_t usage_deny_clear_mask);

  ProducerQueue(size_t meta_size, const UsagePolicy& usage);



  pdx::Status<Entry> OnBufferReady(

      const std::shared_ptr<BufferHubBuffer>& buffer, size_t slot) override;
@@ -317,15 +299,9 @@ class ProducerQueue : public pdx::ClientBase<ProducerQueue, BufferHubQueue> { 


// Explicit specializations of ProducerQueue::Create for void metadata type.

template <>

inline std::unique_ptr<ProducerQueue> ProducerQueue::Create<void>() {

  return ProducerQueue::Create(0);

}

template <>

inline std::unique_ptr<ProducerQueue> ProducerQueue::Create<void>(

    uint32_t usage_set_mask, uint32_t usage_clear_mask,

    uint32_t usage_deny_set_mask, uint32_t usage_deny_clear_mask) {

  return ProducerQueue::Create(0, usage_set_mask, usage_clear_mask,

                               usage_deny_set_mask, usage_deny_clear_mask);

    const UsagePolicy& usage) {

  return ProducerQueue::Create(0, usage);

}



class ConsumerQueue : public BufferHubQueue {

libs/vr/libbufferhubqueue/tests/buffer_hub_queue-test.cpp

+16 −26
Original line number Diff line number Diff line
@@ -25,13 +25,8 @@ constexpr int kBufferUsage = GRALLOC_USAGE_SW_READ_RARELY; 
class BufferHubQueueTest : public ::testing::Test {

 public:

  template <typename Meta>

  bool CreateProducerQueue(uint64_t usage_set_mask = 0,

                           uint64_t usage_clear_mask = 0,

                           uint64_t usage_deny_set_mask = 0,

                           uint64_t usage_deny_clear_mask = 0) {

    producer_queue_ =

        ProducerQueue::Create<Meta>(usage_set_mask, usage_clear_mask,

                                    usage_deny_set_mask, usage_deny_clear_mask);

  bool CreateProducerQueue(const UsagePolicy& usage) {

    producer_queue_ = ProducerQueue::Create<Meta>(usage);

    return producer_queue_ != nullptr;

  }
@@ -45,13 +40,8 @@ class BufferHubQueueTest : public ::testing::Test { 
  }



  template <typename Meta>

  bool CreateQueues(int usage_set_mask = 0, int usage_clear_mask = 0,

                    int usage_deny_set_mask = 0,

                    int usage_deny_clear_mask = 0) {

    return CreateProducerQueue<Meta>(usage_set_mask, usage_clear_mask,

                                     usage_deny_set_mask,

                                     usage_deny_clear_mask) &&

           CreateConsumerQueue();

  bool CreateQueues(const UsagePolicy& usage) {

    return CreateProducerQueue<Meta>(usage) && CreateConsumerQueue();

  }



  void AllocateBuffer(size_t* slot_out = nullptr) {
@@ -74,7 +64,7 @@ class BufferHubQueueTest : public ::testing::Test { 
TEST_F(BufferHubQueueTest, TestDequeue) {

  const size_t nb_dequeue_times = 16;



  ASSERT_TRUE(CreateQueues<size_t>());

  ASSERT_TRUE(CreateQueues<size_t>(UsagePolicy{}));



  // Allocate only one buffer.

  AllocateBuffer();
@@ -104,7 +94,7 @@ TEST_F(BufferHubQueueTest, TestProducerConsumer) { 
  size_t slot;

  uint64_t seq;



  ASSERT_TRUE(CreateQueues<uint64_t>());

  ASSERT_TRUE(CreateQueues<uint64_t>(UsagePolicy{}));



  for (size_t i = 0; i < kBufferCount; i++) {

    AllocateBuffer();
@@ -175,7 +165,7 @@ TEST_F(BufferHubQueueTest, TestProducerConsumer) { 
}



TEST_F(BufferHubQueueTest, TestDetach) {

  ASSERT_TRUE(CreateProducerQueue<void>());

  ASSERT_TRUE(CreateProducerQueue<void>(UsagePolicy{}));



  // Allocate buffers.

  const size_t kBufferCount = 4u;
@@ -278,7 +268,7 @@ TEST_F(BufferHubQueueTest, TestDetach) { 
}



TEST_F(BufferHubQueueTest, TestMultipleConsumers) {

  ASSERT_TRUE(CreateProducerQueue<void>());

  ASSERT_TRUE(CreateProducerQueue<void>(UsagePolicy{}));



  // Allocate buffers.

  const size_t kBufferCount = 4u;
@@ -356,7 +346,7 @@ struct TestMetadata { 
};



TEST_F(BufferHubQueueTest, TestMetadata) {

  ASSERT_TRUE(CreateQueues<TestMetadata>());

  ASSERT_TRUE(CreateQueues<TestMetadata>(UsagePolicy{}));

  AllocateBuffer();



  std::vector<TestMetadata> ms = {
@@ -382,7 +372,7 @@ TEST_F(BufferHubQueueTest, TestMetadata) { 
}



TEST_F(BufferHubQueueTest, TestMetadataMismatch) {

  ASSERT_TRUE(CreateQueues<int64_t>());

  ASSERT_TRUE(CreateQueues<int64_t>(UsagePolicy{}));

  AllocateBuffer();



  int64_t mi = 3;
@@ -401,7 +391,7 @@ TEST_F(BufferHubQueueTest, TestMetadataMismatch) { 
}



TEST_F(BufferHubQueueTest, TestEnqueue) {

  ASSERT_TRUE(CreateQueues<int64_t>());

  ASSERT_TRUE(CreateQueues<int64_t>(UsagePolicy{}));

  AllocateBuffer();



  size_t slot;
@@ -418,7 +408,7 @@ TEST_F(BufferHubQueueTest, TestEnqueue) { 
}



TEST_F(BufferHubQueueTest, TestAllocateBuffer) {

  ASSERT_TRUE(CreateQueues<int64_t>());

  ASSERT_TRUE(CreateQueues<int64_t>(UsagePolicy{}));



  size_t s1;

  AllocateBuffer();
@@ -473,7 +463,7 @@ TEST_F(BufferHubQueueTest, TestAllocateBuffer) { 


TEST_F(BufferHubQueueTest, TestUsageSetMask) {

  const uint32_t set_mask = GRALLOC_USAGE_SW_WRITE_OFTEN;

  ASSERT_TRUE(CreateQueues<int64_t>(set_mask, 0, 0, 0));

  ASSERT_TRUE(CreateQueues<int64_t>(UsagePolicy{set_mask, 0, 0, 0}));



  // When allocation, leave out |set_mask| from usage bits on purpose.

  size_t slot;
@@ -491,7 +481,7 @@ TEST_F(BufferHubQueueTest, TestUsageSetMask) { 


TEST_F(BufferHubQueueTest, TestUsageClearMask) {

  const uint32_t clear_mask = GRALLOC_USAGE_SW_WRITE_OFTEN;

  ASSERT_TRUE(CreateQueues<int64_t>(0, clear_mask, 0, 0));

  ASSERT_TRUE(CreateQueues<int64_t>(UsagePolicy{0, clear_mask, 0, 0}));



  // When allocation, add |clear_mask| into usage bits on purpose.

  size_t slot;
@@ -509,7 +499,7 @@ TEST_F(BufferHubQueueTest, TestUsageClearMask) { 


TEST_F(BufferHubQueueTest, TestUsageDenySetMask) {

  const uint32_t deny_set_mask = GRALLOC_USAGE_SW_WRITE_OFTEN;

  ASSERT_TRUE(CreateQueues<int64_t>(0, 0, deny_set_mask, 0));

  ASSERT_TRUE(CreateQueues<int64_t>(UsagePolicy{0, 0, deny_set_mask, 0}));



  // Now that |deny_set_mask| is illegal, allocation without those bits should

  // be able to succeed.
@@ -529,7 +519,7 @@ TEST_F(BufferHubQueueTest, TestUsageDenySetMask) { 


TEST_F(BufferHubQueueTest, TestUsageDenyClearMask) {

  const uint32_t deny_clear_mask = GRALLOC_USAGE_SW_WRITE_OFTEN;

  ASSERT_TRUE(CreateQueues<int64_t>(0, 0, 0, deny_clear_mask));

  ASSERT_TRUE(CreateQueues<int64_t>(UsagePolicy{0, 0, 0, deny_clear_mask}));



  // Now that clearing |deny_clear_mask| is illegal (i.e. setting these bits are

  // mandatory), allocation with those bits should be able to succeed.