Merge "Revert "use 64-bits usage bits almost everywhere""
diff --git a/cmds/atrace/atrace.cpp b/cmds/atrace/atrace.cpp
index 8d9442b..457d203 100644
--- a/cmds/atrace/atrace.cpp
+++ b/cmds/atrace/atrace.cpp
@@ -30,6 +30,7 @@
#include <unistd.h>
#include <zlib.h>
+#include <fstream>
#include <memory>
#include <binder/IBinder.h>
@@ -172,6 +173,7 @@
{ REQ, "events/vmscan/mm_vmscan_direct_reclaim_end/enable" },
{ REQ, "events/vmscan/mm_vmscan_kswapd_wake/enable" },
{ REQ, "events/vmscan/mm_vmscan_kswapd_sleep/enable" },
+ { REQ, "events/lowmemorykiller/enable" },
} },
{ "regulators", "Voltage and Current Regulators", 0, {
{ REQ, "events/regulator/enable" },
@@ -434,56 +436,31 @@
return writeStr(k_traceBufferSizePath, str);
}
-// Read the trace_clock sysfs file and return true if it matches the requested
-// value. The trace_clock file format is:
-// local [global] counter uptime perf
-static bool isTraceClock(const char *mode)
-{
- int fd = open((g_traceFolder + k_traceClockPath).c_str(), O_RDONLY);
- if (fd == -1) {
- fprintf(stderr, "error opening %s: %s (%d)\n", k_traceClockPath,
- strerror(errno), errno);
- return false;
- }
-
- char buf[4097];
- ssize_t n = read(fd, buf, 4096);
- close(fd);
- if (n == -1) {
- fprintf(stderr, "error reading %s: %s (%d)\n", k_traceClockPath,
- strerror(errno), errno);
- return false;
- }
- buf[n] = '\0';
-
- char *start = strchr(buf, '[');
- if (start == NULL) {
- return false;
- }
- start++;
-
- char *end = strchr(start, ']');
- if (end == NULL) {
- return false;
- }
- *end = '\0';
-
- return strcmp(mode, start) == 0;
-}
-
-// Enable or disable the kernel's use of the global clock. Disabling the global
-// clock will result in the kernel using a per-CPU local clock.
+// Set the clock to the best available option while tracing. Use 'boot' if it's
+// available; otherwise, use 'mono'. If neither are available use 'global'.
// Any write to the trace_clock sysfs file will reset the buffer, so only
// update it if the requested value is not the current value.
-static bool setGlobalClockEnable(bool enable)
+static bool setClock()
{
- const char *clock = enable ? "global" : "local";
+ std::ifstream clockFile((g_traceFolder + k_traceClockPath).c_str(), O_RDONLY);
+ std::string clockStr((std::istreambuf_iterator<char>(clockFile)),
+ std::istreambuf_iterator<char>());
- if (isTraceClock(clock)) {
- return true;
+ std::string newClock;
+ if (clockStr.find("boot") != std::string::npos) {
+ newClock = "boot";
+ } else if (clockStr.find("mono") != std::string::npos) {
+ newClock = "mono";
+ } else {
+ newClock = "global";
}
- return writeStr(k_traceClockPath, clock);
+ size_t begin = clockStr.find("[") + 1;
+ size_t end = clockStr.find("]");
+ if (newClock.compare(0, std::string::npos, clockStr, begin, end-begin) == 0) {
+ return true;
+ }
+ return writeStr(k_traceClockPath, newClock.c_str());
}
static bool setPrintTgidEnableIfPresent(bool enable)
@@ -776,7 +753,7 @@
ok &= setCategoriesEnableFromFile(g_categoriesFile);
ok &= setTraceOverwriteEnable(g_traceOverwrite);
ok &= setTraceBufferSizeKB(g_traceBufferSizeKB);
- ok &= setGlobalClockEnable(true);
+ ok &= setClock();
ok &= setPrintTgidEnableIfPresent(true);
ok &= setKernelTraceFuncs(g_kernelTraceFuncs);
@@ -848,7 +825,6 @@
// Set the options back to their defaults.
setTraceOverwriteEnable(true);
setTraceBufferSizeKB(1);
- setGlobalClockEnable(false);
setPrintTgidEnableIfPresent(false);
setKernelTraceFuncs(NULL);
}
diff --git a/cmds/atrace/atrace.rc b/cmds/atrace/atrace.rc
index cef41be..8201d7e 100644
--- a/cmds/atrace/atrace.rc
+++ b/cmds/atrace/atrace.rc
@@ -51,6 +51,8 @@
chown root shell /sys/kernel/tracing/events/binder/binder_locked/enable
chown root shell /sys/kernel/debug/tracing/events/binder/binder_unlock/enable
chown root shell /sys/kernel/tracing/events/binder/binder_unlock/enable
+ chown root shell /sys/kernel/debug/tracing/events/lowmemorykiller/enable
+ chown root shell /sys/kernel/tracing/events/lowmemorykiller/enable
chown root shell /sys/kernel/debug/tracing/tracing_on
chown root shell /sys/kernel/tracing/tracing_on
@@ -119,11 +121,18 @@
chmod 0664 /sys/kernel/tracing/events/i2c/smbus_result/enable
chmod 0664 /sys/kernel/debug/tracing/events/i2c/smbus_reply/enable
chmod 0664 /sys/kernel/tracing/events/i2c/smbus_reply/enable
+ chmod 0664 /sys/kernel/debug/tracing/events/lowmemorykiller/enable
+ chmod 0664 /sys/kernel/tracing/events/lowmemorykiller/enable
# Tracing disabled by default
write /sys/kernel/debug/tracing/tracing_on 0
write /sys/kernel/tracing/tracing_on 0
+ # Set the trace clock to boot; falling back to mono or boot
+ write /d/tracing/trace_clock global
+ write /d/tracing/trace_clock mono
+ write /d/tracing/trace_clock boot
+
# Allow only the shell group to read and truncate the kernel trace.
chown root shell /sys/kernel/debug/tracing/trace
chown root shell /sys/kernel/tracing/trace
diff --git a/libs/math/tests/mat_test.cpp b/libs/math/tests/mat_test.cpp
index c365366..3217a1a 100644
--- a/libs/math/tests/mat_test.cpp
+++ b/libs/math/tests/mat_test.cpp
@@ -487,7 +487,7 @@
for (size_t i = 0; i < v1.size(); ++i) { \
EXPECT_FLOAT_EQ(v1[i], v2[i]); \
} \
- } else if (std::is_same<TypeParam,float>::value) { \
+ } else if (std::is_same<TypeParam,double>::value) { \
for (size_t i = 0; i < v1.size(); ++i) { \
EXPECT_DOUBLE_EQ(v1[i], v2[i]); \
} \
@@ -506,7 +506,7 @@
const decltype(T2) t2 = T2; \
if (std::is_same<TypeParam,float>::value) { \
ASSERT_FLOAT_EQ(t1, t2); \
- } else if (std::is_same<TypeParam,float>::value) { \
+ } else if (std::is_same<TypeParam,double>::value) { \
ASSERT_DOUBLE_EQ(t1, t2); \
} else { \
ASSERT_EQ(t1, t2); \
diff --git a/libs/vr/libbufferhub/include/private/dvr/bufferhub_rpc.h b/libs/vr/libbufferhub/include/private/dvr/bufferhub_rpc.h
index ffdc9e2..d79d96d 100644
--- a/libs/vr/libbufferhub/include/private/dvr/bufferhub_rpc.h
+++ b/libs/vr/libbufferhub/include/private/dvr/bufferhub_rpc.h
@@ -129,19 +129,102 @@
using LocalFence = FenceHandle<pdx::LocalHandle>;
using BorrowedFence = FenceHandle<pdx::BorrowedHandle>;
-struct QueueInfo {
+struct ProducerQueueConfig {
+ // Whether the buffer queue is operating in Async mode.
+ // From GVR's perspective of view, this means a buffer can be acquired
+ // asynchronously by the compositor.
+ // From Android Surface's perspective of view, this is equivalent to
+ // IGraphicBufferProducer's async mode. When in async mode, a producer
+ // will never block even if consumer is running slow.
+ bool is_async;
+
+ // Default buffer width that is set during ProducerQueue's creation.
+ uint32_t default_width;
+
+ // Default buffer height that is set during ProducerQueue's creation.
+ uint32_t default_height;
+
+ // Default buffer format that is set during ProducerQueue's creation.
+ uint32_t default_format;
+
+ // Size of the meta data associated with all the buffers allocated from the
+ // queue.
size_t meta_size_bytes;
+
+ private:
+ PDX_SERIALIZABLE_MEMBERS(ProducerQueueConfig, is_async, default_width,
+ default_height, default_format, meta_size_bytes);
+};
+
+class ProducerQueueConfigBuilder {
+ public:
+ // Build a ProducerQueueConfig object.
+ ProducerQueueConfig Build() {
+ return {is_async_, default_width_, default_height_, default_format_,
+ meta_size_bytes_};
+ }
+
+ ProducerQueueConfigBuilder& SetIsAsync(bool is_async) {
+ is_async_ = is_async;
+ return *this;
+ }
+
+ ProducerQueueConfigBuilder& SetDefaultWidth(uint32_t width) {
+ default_width_ = width;
+ return *this;
+ }
+
+ ProducerQueueConfigBuilder& SetDefaultHeight(uint32_t height) {
+ default_height_ = height;
+ return *this;
+ }
+
+ ProducerQueueConfigBuilder& SetDefaultFormat(uint32_t format) {
+ default_format_ = format;
+ return *this;
+ }
+
+ template <typename Meta>
+ ProducerQueueConfigBuilder& SetMetadata() {
+ meta_size_bytes_ = sizeof(Meta);
+ return *this;
+ }
+
+ ProducerQueueConfigBuilder& SetMetadataSize(size_t meta_size_bytes) {
+ meta_size_bytes_ = meta_size_bytes;
+ return *this;
+ }
+
+ private:
+ bool is_async_{false};
+ uint32_t default_width_{1};
+ uint32_t default_height_{1};
+ uint32_t default_format_{1}; // PIXEL_FORMAT_RGBA_8888
+ size_t meta_size_bytes_{0};
+};
+
+// Explicit specializations of ProducerQueueConfigBuilder::Build for void
+// metadata type.
+template <>
+inline ProducerQueueConfigBuilder&
+ProducerQueueConfigBuilder::SetMetadata<void>() {
+ meta_size_bytes_ = 0;
+ return *this;
+}
+
+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,
@@ -219,7 +302,7 @@
// Buffer Queue Methods.
PDX_REMOTE_METHOD(CreateProducerQueue, kOpCreateProducerQueue,
- QueueInfo(size_t meta_size_bytes,
+ QueueInfo(const ProducerQueueConfig& producer_config,
const UsagePolicy& usage_policy));
PDX_REMOTE_METHOD(CreateConsumerQueue, kOpCreateConsumerQueue,
LocalChannelHandle(Void));
diff --git a/libs/vr/libbufferhubqueue/buffer_hub_queue_client.cpp b/libs/vr/libbufferhubqueue/buffer_hub_queue_client.cpp
index 1978f41..e59bbb5 100644
--- a/libs/vr/libbufferhubqueue/buffer_hub_queue_client.cpp
+++ b/libs/vr/libbufferhubqueue/buffer_hub_queue_client.cpp
@@ -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,14 +105,18 @@
status.GetErrorMessage().c_str());
return ErrorStatus(status.error());
} else {
- SetupQueue(status.get().meta_size_bytes, status.get().id);
+ SetupQueue(status.get());
return {};
}
}
-void BufferHubQueue::SetupQueue(size_t meta_size_bytes, int id) {
- meta_size_ = meta_size_bytes;
- id_ = id;
+void BufferHubQueue::SetupQueue(const QueueInfo& queue_info) {
+ is_async_ = queue_info.producer_config.is_async;
+ default_width_ = queue_info.producer_config.default_width;
+ default_height_ = queue_info.producer_config.default_height;
+ default_format_ = queue_info.producer_config.default_format;
+ meta_size_ = queue_info.producer_config.meta_size_bytes;
+ id_ = queue_info.id;
}
std::unique_ptr<ConsumerQueue> BufferHubQueue::CreateConsumerQueue() {
@@ -396,9 +399,6 @@
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 +409,11 @@
}
}
-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(const ProducerQueueConfig& config,
+ 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>(config, usage);
if (!status) {
ALOGE("ProducerQueue::ProducerQueue: Failed to create producer queue: %s",
status.GetErrorMessage().c_str());
@@ -424,7 +421,7 @@
return;
}
- SetupQueue(status.get().meta_size_bytes, status.get().id);
+ SetupQueue(status.get());
}
Status<void> ProducerQueue::AllocateBuffer(uint32_t width, uint32_t height,
diff --git a/libs/vr/libbufferhubqueue/buffer_hub_queue_producer.cpp b/libs/vr/libbufferhubqueue/buffer_hub_queue_producer.cpp
index 932aa37..4b3dd7a 100644
--- a/libs/vr/libbufferhubqueue/buffer_hub_queue_producer.cpp
+++ b/libs/vr/libbufferhubqueue/buffer_hub_queue_producer.cpp
@@ -11,7 +11,10 @@
/* static */
sp<BufferHubQueueProducer> BufferHubQueueProducer::Create() {
sp<BufferHubQueueProducer> producer = new BufferHubQueueProducer;
- producer->queue_ = ProducerQueue::Create<DvrNativeBufferMetadata>();
+ auto config = ProducerQueueConfigBuilder()
+ .SetMetadata<DvrNativeBufferMetadata>()
+ .Build();
+ producer->queue_ = ProducerQueue::Create(config, UsagePolicy{});
return producer;
}
diff --git a/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_client.h b/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_client.h
index d8d326b..e62e832 100644
--- a/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_client.h
+++ b/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_client.h
@@ -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>
@@ -32,14 +33,17 @@
// participation in lifecycle events.
std::unique_ptr<ConsumerQueue> CreateSilentConsumerQueue();
+ // Returns whether the buffer queue is in async mode.
+ bool is_async() const { return is_async_; }
+
// Returns the default buffer width of this buffer queue.
- size_t default_width() const { return default_width_; }
+ uint32_t default_width() const { return default_width_; }
// Returns the default buffer height of this buffer queue.
- size_t default_height() const { return default_height_; }
+ uint32_t default_height() const { return default_height_; }
// Returns the default buffer format of this buffer queue.
- int32_t default_format() const { return default_format_; }
+ uint32_t default_format() const { return default_format_; }
// Creates a new consumer in handle form for immediate transport over RPC.
pdx::Status<pdx::LocalChannelHandle> CreateConsumerQueueHandle();
@@ -98,7 +102,7 @@
pdx::Status<void> ImportQueue();
// Sets up the queue with the given parameters.
- void SetupQueue(size_t meta_size_bytes_, int id);
+ void SetupQueue(const QueueInfo& queue_info);
// Register a buffer for management by the queue. Used by subclasses to add a
// buffer to internal bookkeeping.
@@ -181,17 +185,22 @@
return index == BufferHubQueue::kEpollQueueEventIndex;
}
- // Default buffer width that can be set to override the buffer width when a
- // width and height of 0 are specified in AllocateBuffer.
+ // Whether the buffer queue is operating in Async mode.
+ // From GVR's perspective of view, this means a buffer can be acquired
+ // asynchronously by the compositor.
+ // From Android Surface's perspective of view, this is equivalent to
+ // IGraphicBufferProducer's async mode. When in async mode, a producer
+ // will never block even if consumer is running slow.
+ bool is_async_{false};
+
+ // Default buffer width that is set during ProducerQueue's creation.
size_t default_width_{1};
- // Default buffer height that can be set to override the buffer height when a
- // width and height of 0 are specified in AllocateBuffer.
+ // Default buffer height that is set during ProducerQueue's creation.
size_t default_height_{1};
- // Default buffer format that can be set to override the buffer format when it
- // isn't specified in AllocateBuffer.
- int32_t default_format_{PIXEL_FORMAT_RGBA_8888};
+ // Default buffer format that is set during ProducerQueue's creation.
+ int32_t default_format_{1}; // PIXEL_FORMAT_RGBA_8888
// Tracks the buffers belonging to this queue. Buffers are stored according to
// "slot" in this vector. Each slot is a logical id of the buffer within this
@@ -222,14 +231,6 @@
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
@@ -241,21 +242,9 @@
// this will be rejected. Note that |usage_deny_set_mask| and
// |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(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);
+ static std::unique_ptr<ProducerQueue> Create(
+ const ProducerQueueConfig& config, const UsagePolicy& usage) {
+ return BASE::Create(config, usage);
}
// Import a ProducerQueue from a channel handle.
@@ -305,29 +294,13 @@
// 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(const ProducerQueueConfig& config, const UsagePolicy& usage);
pdx::Status<Entry> OnBufferReady(
const std::shared_ptr<BufferHubBuffer>& buffer, size_t slot) override;
};
-// 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);
-}
-
class ConsumerQueue : public BufferHubQueue {
public:
// Get a buffer consumer. Note that the method doesn't check whether the
diff --git a/libs/vr/libbufferhubqueue/tests/buffer_hub_queue-test.cpp b/libs/vr/libbufferhubqueue/tests/buffer_hub_queue-test.cpp
index ff2e146..064e3fd 100644
--- a/libs/vr/libbufferhubqueue/tests/buffer_hub_queue-test.cpp
+++ b/libs/vr/libbufferhubqueue/tests/buffer_hub_queue-test.cpp
@@ -16,22 +16,17 @@
namespace {
-constexpr int kBufferWidth = 100;
-constexpr int kBufferHeight = 1;
-constexpr int kBufferLayerCount = 1;
-constexpr int kBufferFormat = HAL_PIXEL_FORMAT_BLOB;
-constexpr int kBufferUsage = GRALLOC_USAGE_SW_READ_RARELY;
+constexpr uint32_t kBufferWidth = 100;
+constexpr uint32_t kBufferHeight = 1;
+constexpr uint32_t kBufferLayerCount = 1;
+constexpr uint32_t kBufferFormat = HAL_PIXEL_FORMAT_BLOB;
+constexpr uint64_t 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 ProducerQueueConfig& config,
+ const UsagePolicy& usage) {
+ producer_queue_ = ProducerQueue::Create(config, usage);
return producer_queue_ != nullptr;
}
@@ -44,14 +39,9 @@
}
}
- 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 ProducerQueueConfig& config,
+ const UsagePolicy& usage) {
+ return CreateProducerQueue(config, usage) && CreateConsumerQueue();
}
void AllocateBuffer(size_t* slot_out = nullptr) {
@@ -67,6 +57,7 @@
}
protected:
+ ProducerQueueConfigBuilder config_builder_;
std::unique_ptr<ProducerQueue> producer_queue_;
std::unique_ptr<ConsumerQueue> consumer_queue_;
};
@@ -74,7 +65,8 @@
TEST_F(BufferHubQueueTest, TestDequeue) {
const size_t nb_dequeue_times = 16;
- ASSERT_TRUE(CreateQueues<size_t>());
+ ASSERT_TRUE(CreateQueues(config_builder_.SetMetadata<size_t>().Build(),
+ UsagePolicy{}));
// Allocate only one buffer.
AllocateBuffer();
@@ -104,7 +96,8 @@
size_t slot;
uint64_t seq;
- ASSERT_TRUE(CreateQueues<uint64_t>());
+ ASSERT_TRUE(CreateQueues(config_builder_.SetMetadata<uint64_t>().Build(),
+ UsagePolicy{}));
for (size_t i = 0; i < kBufferCount; i++) {
AllocateBuffer();
@@ -175,7 +168,7 @@
}
TEST_F(BufferHubQueueTest, TestDetach) {
- ASSERT_TRUE(CreateProducerQueue<void>());
+ ASSERT_TRUE(CreateProducerQueue(config_builder_.Build(), UsagePolicy{}));
// Allocate buffers.
const size_t kBufferCount = 4u;
@@ -278,7 +271,9 @@
}
TEST_F(BufferHubQueueTest, TestMultipleConsumers) {
- ASSERT_TRUE(CreateProducerQueue<void>());
+ // ProducerConfigureBuilder doesn't set Metadata{size}, which means there
+ // is no metadata associated with this BufferQueue's buffer.
+ ASSERT_TRUE(CreateProducerQueue(config_builder_.Build(), UsagePolicy{}));
// Allocate buffers.
const size_t kBufferCount = 4u;
@@ -356,7 +351,9 @@
};
TEST_F(BufferHubQueueTest, TestMetadata) {
- ASSERT_TRUE(CreateQueues<TestMetadata>());
+ ASSERT_TRUE(CreateQueues(config_builder_.SetMetadata<TestMetadata>().Build(),
+ UsagePolicy{}));
+
AllocateBuffer();
std::vector<TestMetadata> ms = {
@@ -382,7 +379,9 @@
}
TEST_F(BufferHubQueueTest, TestMetadataMismatch) {
- ASSERT_TRUE(CreateQueues<int64_t>());
+ ASSERT_TRUE(CreateQueues(config_builder_.SetMetadata<int64_t>().Build(),
+ UsagePolicy{}));
+
AllocateBuffer();
int64_t mi = 3;
@@ -401,7 +400,8 @@
}
TEST_F(BufferHubQueueTest, TestEnqueue) {
- ASSERT_TRUE(CreateQueues<int64_t>());
+ ASSERT_TRUE(CreateQueues(config_builder_.SetMetadata<int64_t>().Build(),
+ UsagePolicy{}));
AllocateBuffer();
size_t slot;
@@ -418,7 +418,8 @@
}
TEST_F(BufferHubQueueTest, TestAllocateBuffer) {
- ASSERT_TRUE(CreateQueues<int64_t>());
+ ASSERT_TRUE(CreateQueues(config_builder_.SetMetadata<int64_t>().Build(),
+ UsagePolicy{}));
size_t s1;
AllocateBuffer();
@@ -473,7 +474,8 @@
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(config_builder_.SetMetadata<int64_t>().Build(),
+ UsagePolicy{set_mask, 0, 0, 0}));
// When allocation, leave out |set_mask| from usage bits on purpose.
size_t slot;
@@ -491,7 +493,8 @@
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(config_builder_.SetMetadata<int64_t>().Build(),
+ UsagePolicy{0, clear_mask, 0, 0}));
// When allocation, add |clear_mask| into usage bits on purpose.
size_t slot;
@@ -509,7 +512,8 @@
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(config_builder_.SetMetadata<int64_t>().Build(),
+ 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 +533,8 @@
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(config_builder_.SetMetadata<int64_t>().Build(),
+ 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.
@@ -547,6 +552,26 @@
ASSERT_EQ(EINVAL, status.error());
}
+TEST_F(BufferHubQueueTest, TestQueueInfo) {
+ static const bool kIsAsync = true;
+ ASSERT_TRUE(CreateQueues(config_builder_.SetIsAsync(kIsAsync)
+ .SetDefaultWidth(kBufferWidth)
+ .SetDefaultHeight(kBufferHeight)
+ .SetDefaultFormat(kBufferFormat)
+ .Build(),
+ UsagePolicy{}));
+
+ EXPECT_EQ(producer_queue_->default_width(), kBufferWidth);
+ EXPECT_EQ(producer_queue_->default_height(), kBufferHeight);
+ EXPECT_EQ(producer_queue_->default_format(), kBufferFormat);
+ EXPECT_EQ(producer_queue_->is_async(), kIsAsync);
+
+ EXPECT_EQ(consumer_queue_->default_width(), kBufferWidth);
+ EXPECT_EQ(consumer_queue_->default_height(), kBufferHeight);
+ EXPECT_EQ(consumer_queue_->default_format(), kBufferFormat);
+ EXPECT_EQ(consumer_queue_->is_async(), kIsAsync);
+}
+
} // namespace
} // namespace dvr
diff --git a/libs/vr/libdvr/tests/dvr_buffer_queue-test.cpp b/libs/vr/libdvr/tests/dvr_buffer_queue-test.cpp
index 5d12020..2426a49 100644
--- a/libs/vr/libdvr/tests/dvr_buffer_queue-test.cpp
+++ b/libs/vr/libdvr/tests/dvr_buffer_queue-test.cpp
@@ -25,8 +25,9 @@
class DvrBufferQueueTest : public ::testing::Test {
protected:
void SetUp() override {
+ auto config = ProducerQueueConfigBuilder().SetMetadata<TestMeta>().Build();
write_queue_ = CreateDvrWriteBufferQueueFromProducerQueue(
- ProducerQueue::Create<TestMeta>(0, 0, 0, 0));
+ ProducerQueue::Create(config, UsagePolicy{}));
ASSERT_NE(nullptr, write_queue_);
}
@@ -197,11 +198,13 @@
ASSERT_EQ(nullptr, window);
// A write queue with DvrNativeBufferMetadata should work fine.
+ auto config = ProducerQueueConfigBuilder()
+ .SetMetadata<DvrNativeBufferMetadata>()
+ .Build();
std::unique_ptr<DvrWriteBufferQueue, decltype(&dvrWriteBufferQueueDestroy)>
- write_queue(
- CreateDvrWriteBufferQueueFromProducerQueue(
- ProducerQueue::Create<DvrNativeBufferMetadata>(0, 0, 0, 0)),
- dvrWriteBufferQueueDestroy);
+ write_queue(CreateDvrWriteBufferQueueFromProducerQueue(
+ ProducerQueue::Create(config, UsagePolicy{})),
+ dvrWriteBufferQueueDestroy);
ASSERT_NE(nullptr, write_queue.get());
ret = dvrWriteBufferQueueGetExternalSurface(write_queue.get(), &window);
diff --git a/libs/vr/libvrflinger/display_surface.cpp b/libs/vr/libvrflinger/display_surface.cpp
index 6917b8c..babdc0e 100644
--- a/libs/vr/libvrflinger/display_surface.cpp
+++ b/libs/vr/libvrflinger/display_surface.cpp
@@ -207,7 +207,9 @@
surface_id(), meta_size_bytes);
std::lock_guard<std::mutex> autolock(lock_);
- auto producer = ProducerQueue::Create(meta_size_bytes);
+ auto config =
+ ProducerQueueConfigBuilder().SetMetadataSize(meta_size_bytes).Build();
+ auto producer = ProducerQueue::Create(config, UsagePolicy{});
if (!producer) {
ALOGE(
"ApplicationDisplaySurface::OnCreateQueue: Failed to create producer "
@@ -270,8 +272,10 @@
if (!direct_queue_) {
// Inject the hw composer usage flag to enable the display to read the
// buffers.
+ auto config =
+ ProducerQueueConfigBuilder().SetMetadataSize(meta_size_bytes).Build();
auto producer = ProducerQueue::Create(
- meta_size_bytes, GraphicBuffer::USAGE_HW_COMPOSER, 0, 0, 0);
+ config, UsagePolicy{GraphicBuffer::USAGE_HW_COMPOSER, 0, 0, 0});
if (!producer) {
ALOGE(
"DirectDisplaySurface::OnCreateQueue: Failed to create producer "
diff --git a/services/vr/bufferhubd/buffer_hub.cpp b/services/vr/bufferhubd/buffer_hub.cpp
index d27f274..26843c9 100644
--- a/services/vr/bufferhubd/buffer_hub.cpp
+++ b/services/vr/bufferhubd/buffer_hub.cpp
@@ -382,7 +382,7 @@
}
Status<QueueInfo> BufferHubService::OnCreateProducerQueue(
- pdx::Message& message, size_t meta_size_bytes,
+ pdx::Message& message, const ProducerQueueConfig& producer_config,
const UsagePolicy& usage_policy) {
// Use the producer channel id as the global queue id.
const int queue_id = message.GetChannelId();
@@ -396,11 +396,11 @@
return ErrorStatus(EALREADY);
}
- auto status = ProducerQueueChannel::Create(this, queue_id, meta_size_bytes,
+ auto status = ProducerQueueChannel::Create(this, queue_id, producer_config,
usage_policy);
if (status) {
message.SetChannel(status.take());
- return {{meta_size_bytes, queue_id}};
+ return {{producer_config, queue_id}};
} else {
ALOGE("BufferHubService::OnCreateBuffer: Failed to create producer!!");
return status.error_status();
diff --git a/services/vr/bufferhubd/buffer_hub.h b/services/vr/bufferhubd/buffer_hub.h
index 3bc2635..b0df11f 100644
--- a/services/vr/bufferhubd/buffer_hub.h
+++ b/services/vr/bufferhubd/buffer_hub.h
@@ -166,9 +166,9 @@
size_t meta_size_bytes);
pdx::Status<void> OnGetPersistentBuffer(pdx::Message& message,
const std::string& name);
- pdx::Status<QueueInfo> OnCreateProducerQueue(pdx::Message& message,
- size_t meta_size_bytes,
- const UsagePolicy& usage_policy);
+ pdx::Status<QueueInfo> OnCreateProducerQueue(
+ pdx::Message& message, const ProducerQueueConfig& producer_config,
+ const UsagePolicy& usage_policy);
BufferHubService(const BufferHubService&) = delete;
void operator=(const BufferHubService&) = delete;
diff --git a/services/vr/bufferhubd/producer_queue_channel.cpp b/services/vr/bufferhubd/producer_queue_channel.cpp
index 886e621..605b8fb 100644
--- a/services/vr/bufferhubd/producer_queue_channel.cpp
+++ b/services/vr/bufferhubd/producer_queue_channel.cpp
@@ -16,11 +16,11 @@
ProducerQueueChannel::ProducerQueueChannel(BufferHubService* service,
int channel_id,
- size_t meta_size_bytes,
+ const ProducerQueueConfig& config,
const UsagePolicy& usage_policy,
int* error)
: BufferHubChannel(service, channel_id, channel_id, kProducerQueueType),
- meta_size_bytes_(meta_size_bytes),
+ config_(config),
usage_policy_(usage_policy),
capacity_(0) {
*error = 0;
@@ -35,8 +35,8 @@
/* static */
Status<std::shared_ptr<ProducerQueueChannel>> ProducerQueueChannel::Create(
- BufferHubService* service, int channel_id, size_t meta_size_bytes,
- const UsagePolicy& usage_policy) {
+ BufferHubService* service, int channel_id,
+ const ProducerQueueConfig& config, const UsagePolicy& usage_policy) {
// Configuration between |usage_deny_set_mask| and |usage_deny_clear_mask|
// should be mutually exclusive.
if ((usage_policy.usage_deny_set_mask & usage_policy.usage_deny_clear_mask)) {
@@ -50,7 +50,7 @@
int error = 0;
std::shared_ptr<ProducerQueueChannel> producer(new ProducerQueueChannel(
- service, channel_id, meta_size_bytes, usage_policy, &error));
+ service, channel_id, config, usage_policy, &error));
if (error < 0)
return ErrorStatus(-error);
else
@@ -134,7 +134,7 @@
}
Status<QueueInfo> ProducerQueueChannel::OnGetQueueInfo(Message&) {
- return {{meta_size_bytes_, buffer_id()}};
+ return {{config_, buffer_id()}};
}
Status<std::vector<std::pair<RemoteChannelHandle, size_t>>>
@@ -222,7 +222,7 @@
auto producer_channel_status =
ProducerChannel::Create(service(), buffer_id, width, height, layer_count,
- format, usage, meta_size_bytes_);
+ format, usage, config_.meta_size_bytes);
if (!producer_channel_status) {
ALOGE(
"ProducerQueueChannel::AllocateBuffer: Failed to create producer "
diff --git a/services/vr/bufferhubd/producer_queue_channel.h b/services/vr/bufferhubd/producer_queue_channel.h
index 28c74cd..212a90d 100644
--- a/services/vr/bufferhubd/producer_queue_channel.h
+++ b/services/vr/bufferhubd/producer_queue_channel.h
@@ -12,8 +12,8 @@
class ProducerQueueChannel : public BufferHubChannel {
public:
static pdx::Status<std::shared_ptr<ProducerQueueChannel>> Create(
- BufferHubService* service, int channel_id, size_t meta_size_bytes,
- const UsagePolicy& usage_policy);
+ BufferHubService* service, int channel_id,
+ const ProducerQueueConfig& config, const UsagePolicy& usage_policy);
~ProducerQueueChannel() override;
bool HandleMessage(pdx::Message& message) override;
@@ -48,8 +48,8 @@
private:
ProducerQueueChannel(BufferHubService* service, int channel_id,
- size_t meta_size_bytes, const UsagePolicy& usage_policy,
- int* error);
+ const ProducerQueueConfig& config,
+ const UsagePolicy& usage_policy, int* error);
// Allocate one single producer buffer by |OnProducerQueueAllocateBuffers|.
// Note that the newly created buffer's file handle will be pushed to client
@@ -60,10 +60,9 @@
pdx::Message& message, uint32_t width, uint32_t height,
uint32_t layer_count, uint32_t format, uint64_t usage);
- // Size of the meta data associated with all the buffers allocated from the
- // queue. Now we assume the metadata size is immutable once the queue is
- // created.
- size_t meta_size_bytes_;
+ // The producer queue's configuration. Now we assume the configuration is
+ // immutable once the queue is created.
+ ProducerQueueConfig config_;
// A set of variables to control what |usage| bits can this ProducerQueue
// allocate.