Merge "Refactor SensorsTestSharedMemory" (69432670) · Commits · e / os / android_hardware_interfaces

sensors/1.0/vts/functional/VtsHalSensorsV1_0TargetTest.cpp

+1 −213

Original line number	Diff line number	Diff line
		@@ -19,237 +19,25 @@
		#include "SensorsHidlEnvironmentV1_0.h"
		#include "sensors-vts-utils/GrallocWrapper.h"
		#include "sensors-vts-utils/SensorEventsChecker.h"
		#include "sensors-vts-utils/SensorsTestSharedMemory.h"

		#include <VtsHalHidlTargetTestBase.h>
		#include <VtsHalHidlTargetTestEnvBase.h>
		#include <android-base/logging.h>
		#include <android/hardware/sensors/1.0/ISensors.h>
		#include <android/hardware/sensors/1.0/types.h>
		#include <cutils/ashmem.h>
		#include <hardware/sensors.h> // for sensor type strings
		#include <log/log.h>
		#include <utils/SystemClock.h>

		#include <algorithm>
		#include <cinttypes>
		#include <cmath>
		#include <memory>
		#include <mutex>
		#include <thread>
		#include <unordered_set>
		#include <vector>

		#include <sys/mman.h>
		#include <unistd.h>

		using ::android::GrallocWrapper;
		using ::android::hardware::Return;
		using ::android::hardware::Void;
		using ::android::hardware::hidl_string;
		using ::android::sp;
		using namespace ::android::hardware::sensors::V1_0;

		class SensorsTestSharedMemory {
		public:
		static SensorsTestSharedMemory* create(SharedMemType type, size_t size);
		SharedMemInfo getSharedMemInfo() const;
		char * getBuffer() const;
		std::vector<Event> parseEvents(int64_t lastCounter = -1, size_t offset = 0) const;
		virtual ~SensorsTestSharedMemory();
		private:
		SensorsTestSharedMemory(SharedMemType type, size_t size);

		SharedMemType mType;
		native_handle_t* mNativeHandle;
		size_t mSize;
		char* mBuffer;
		std::unique_ptr<GrallocWrapper> mGrallocWrapper;

		DISALLOW_COPY_AND_ASSIGN(SensorsTestSharedMemory);
		};

		SharedMemInfo SensorsTestSharedMemory::getSharedMemInfo() const {
		SharedMemInfo mem = {
		.type = mType,
		.format = SharedMemFormat::SENSORS_EVENT,
		.size = static_cast<uint32_t>(mSize),
		.memoryHandle = mNativeHandle
		};
		return mem;
		}

		char * SensorsTestSharedMemory::getBuffer() const {
		return mBuffer;
		}

		std::vector<Event> SensorsTestSharedMemory::parseEvents(int64_t lastCounter, size_t offset) const {

		constexpr size_t kEventSize = static_cast<size_t>(SensorsEventFormatOffset::TOTAL_LENGTH);
		constexpr size_t kOffsetSize = static_cast<size_t>(SensorsEventFormatOffset::SIZE_FIELD);
		constexpr size_t kOffsetToken = static_cast<size_t>(SensorsEventFormatOffset::REPORT_TOKEN);
		constexpr size_t kOffsetType = static_cast<size_t>(SensorsEventFormatOffset::SENSOR_TYPE);
		constexpr size_t kOffsetAtomicCounter =
		static_cast<size_t>(SensorsEventFormatOffset::ATOMIC_COUNTER);
		constexpr size_t kOffsetTimestamp = static_cast<size_t>(SensorsEventFormatOffset::TIMESTAMP);
		constexpr size_t kOffsetData = static_cast<size_t>(SensorsEventFormatOffset::DATA);

		std::vector<Event> events;
		std::vector<float> data(16);

		while (offset + kEventSize <= mSize) {
		int64_t atomicCounter = reinterpret_cast<uint32_t >(mBuffer + offset + kOffsetAtomicCounter);
		if (atomicCounter <= lastCounter) {
		ALOGV("atomicCounter = %" PRId64 ", lastCounter = %" PRId64, atomicCounter, lastCounter);
		break;
		}

		int32_t size = reinterpret_cast<int32_t >(mBuffer + offset + kOffsetSize);
		if (size != kEventSize) {
		// unknown error, events parsed may be wrong, remove all
		events.clear();
		break;
		}

		int32_t token = reinterpret_cast<int32_t >(mBuffer + offset + kOffsetToken);
		int32_t type = reinterpret_cast<int32_t >(mBuffer + offset + kOffsetType);
		int64_t timestamp = reinterpret_cast<int64_t >(mBuffer + offset + kOffsetTimestamp);

		ALOGV("offset = %zu, cnt %" PRId64 ", token %" PRId32 ", type %" PRId32 ", timestamp %" PRId64,
		offset, atomicCounter, token, type, timestamp);

		Event event = {
		.timestamp = timestamp,
		.sensorHandle = token,
		.sensorType = static_cast<SensorType>(type),
		};
		event.u.data = android::hardware::hidl_array<float, 16>
		(reinterpret_cast<float*>(mBuffer + offset + kOffsetData));

		events.push_back(event);

		lastCounter = atomicCounter;
		offset += kEventSize;
		}

		return events;
		}

		SensorsTestSharedMemory::SensorsTestSharedMemory(SharedMemType type, size_t size)
		: mType(type), mSize(0), mBuffer(nullptr) {
		native_handle_t *handle = nullptr;
		char *buffer = nullptr;
		switch(type) {
		case SharedMemType::ASHMEM: {
		int fd;
		handle = ::native_handle_create(1 /nFds/, 0/nInts/);
		if (handle != nullptr) {
		handle->data[0] = fd = ::ashmem_create_region("SensorsTestSharedMemory", size);
		if (handle->data[0] > 0) {
		// memory is pinned by default
		buffer = static_cast<char *>
		(::mmap(NULL, size, PROT_READ \| PROT_WRITE, MAP_SHARED, fd, 0));
		if (buffer != reinterpret_cast<char*>(MAP_FAILED)) {
		break;
		}
		::native_handle_close(handle);
		}
		::native_handle_delete(handle);
		handle = nullptr;
		}
		break;
		}
		case SharedMemType::GRALLOC: {
		mGrallocWrapper = std::make_unique<GrallocWrapper>();
		if (mGrallocWrapper->getAllocator() == nullptr \|\| mGrallocWrapper->getMapper() == nullptr) {
		break;
		}
		using android::hardware::graphics::common::V1_0::BufferUsage;
		using android::hardware::graphics::common::V1_0::PixelFormat;
		mapper2::IMapper::BufferDescriptorInfo buf_desc_info = {
		.width = static_cast<uint32_t>(size),
		.height = 1,
		.layerCount = 1,
		.usage = static_cast<uint64_t> (BufferUsage::SENSOR_DIRECT_DATA \|
		BufferUsage::CPU_READ_OFTEN),
		.format = PixelFormat::BLOB
		};

		handle = const_cast<native_handle_t *>(mGrallocWrapper->allocate(buf_desc_info));
		if (handle != nullptr) {
		mapper2::IMapper::Rect region{0, 0,
		static_cast<int32_t>(buf_desc_info.width),
		static_cast<int32_t>(buf_desc_info.height)};
		buffer = static_cast<char *>
		(mGrallocWrapper->lock(handle, buf_desc_info.usage, region, /fence=/-1));
		if (buffer != nullptr) {
		break;
		}
		mGrallocWrapper->freeBuffer(handle);
		handle = nullptr;
		}
		break;
		}
		default:
		break;
		}

		if (buffer != nullptr) {
		mNativeHandle = handle;
		mSize = size;
		mBuffer = buffer;
		}
		}

		SensorsTestSharedMemory::~SensorsTestSharedMemory() {
		switch(mType) {
		case SharedMemType::ASHMEM: {
		if (mSize != 0) {
		::munmap(mBuffer, mSize);
		mBuffer = nullptr;

		::native_handle_close(mNativeHandle);
		::native_handle_delete(mNativeHandle);

		mNativeHandle = nullptr;
		mSize = 0;
		}
		break;
		}
		case SharedMemType::GRALLOC: {
		if (mSize != 0) {
		mGrallocWrapper->unlock(mNativeHandle);
		mGrallocWrapper->freeBuffer(mNativeHandle);

		mNativeHandle = nullptr;
		mSize = 0;
		}
		break;
		}
		default: {
		if (mNativeHandle != nullptr \|\| mSize != 0 \|\| mBuffer != nullptr) {
		ALOGE("SensorsTestSharedMemory %p not properly destructed: "
		"type %d, native handle %p, size %zu, buffer %p",
		this, static_cast<int>(mType), mNativeHandle, mSize, mBuffer);
		}
		break;
		}
		}
		}

		SensorsTestSharedMemory* SensorsTestSharedMemory::create(SharedMemType type, size_t size) {
		constexpr size_t kMaxSize = 12810241024; // sensor test should not need more than 128M
		if (size == 0 \|\| size >= kMaxSize) {
		return nullptr;
		}

		auto m = new SensorsTestSharedMemory(type, size);
		if (m->mSize != size \|\| m->mBuffer == nullptr) {
		delete m;
		m = nullptr;
		}
		return m;
		}

		// The main test class for SENSORS HIDL HAL.
		class SensorsHidlTest : public ::testing::VtsHalHidlTargetTestBase {
		public:

sensors/common/vts/utils/Android.bp

+1 −1

Original line number	Diff line number	Diff line
		@@ -19,6 +19,7 @@ cc_library_static {
		srcs: [
		"GrallocWrapper.cpp",
		"SensorsHidlEnvironmentBase.cpp",
		"SensorsTestSharedMemory.cpp",
		],
		export_include_dirs: [
		"include",
		@@ -33,4 +34,3 @@ cc_library_static {
		"VtsHalHidlTargetTestBase",
		],
		}

sensors/common/vts/utils/OWNERS

0 → 100644

+7 −0

Original line number	Diff line number	Diff line
		# Sensors team
		bduddie@google.com
		bstack@google.com

		# VTS team
		trong@google.com
		yim@google.com

sensors/common/vts/utils/SensorsTestSharedMemory.cpp

0 → 100644

+206 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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 "SensorsTestSharedMemory.h"

		#include <log/log.h>

		#include <sys/mman.h>
		#include <cinttypes>

		using namespace ::android::hardware::sensors::V1_0;

		SharedMemInfo SensorsTestSharedMemory::getSharedMemInfo() const {
		SharedMemInfo mem = {.type = mType,
		.format = SharedMemFormat::SENSORS_EVENT,
		.size = static_cast<uint32_t>(mSize),
		.memoryHandle = mNativeHandle};
		return mem;
		}

		char* SensorsTestSharedMemory::getBuffer() const {
		return mBuffer;
		}

		std::vector<Event> SensorsTestSharedMemory::parseEvents(int64_t lastCounter, size_t offset) const {
		constexpr size_t kEventSize = static_cast<size_t>(SensorsEventFormatOffset::TOTAL_LENGTH);
		constexpr size_t kOffsetSize = static_cast<size_t>(SensorsEventFormatOffset::SIZE_FIELD);
		constexpr size_t kOffsetToken = static_cast<size_t>(SensorsEventFormatOffset::REPORT_TOKEN);
		constexpr size_t kOffsetType = static_cast<size_t>(SensorsEventFormatOffset::SENSOR_TYPE);
		constexpr size_t kOffsetAtomicCounter =
		static_cast<size_t>(SensorsEventFormatOffset::ATOMIC_COUNTER);
		constexpr size_t kOffsetTimestamp = static_cast<size_t>(SensorsEventFormatOffset::TIMESTAMP);
		constexpr size_t kOffsetData = static_cast<size_t>(SensorsEventFormatOffset::DATA);

		std::vector<Event> events;
		std::vector<float> data(16);

		while (offset + kEventSize <= mSize) {
		int64_t atomicCounter =
		reinterpret_cast<uint32_t>(mBuffer + offset + kOffsetAtomicCounter);
		if (atomicCounter <= lastCounter) {
		ALOGV("atomicCounter = %" PRId64 ", lastCounter = %" PRId64, atomicCounter,
		lastCounter);
		break;
		}

		int32_t size = reinterpret_cast<int32_t>(mBuffer + offset + kOffsetSize);
		if (size != kEventSize) {
		// unknown error, events parsed may be wrong, remove all
		events.clear();
		break;
		}

		int32_t token = reinterpret_cast<int32_t>(mBuffer + offset + kOffsetToken);
		int32_t type = reinterpret_cast<int32_t>(mBuffer + offset + kOffsetType);
		int64_t timestamp = reinterpret_cast<int64_t>(mBuffer + offset + kOffsetTimestamp);

		ALOGV("offset = %zu, cnt %" PRId64 ", token %" PRId32 ", type %" PRId32
		", timestamp %" PRId64,
		offset, atomicCounter, token, type, timestamp);

		Event event = {
		.timestamp = timestamp,
		.sensorHandle = token,
		.sensorType = static_cast<SensorType>(type),
		};
		event.u.data = android::hardware::hidl_array<float, 16>(
		reinterpret_cast<float*>(mBuffer + offset + kOffsetData));

		events.push_back(event);

		lastCounter = atomicCounter;
		offset += kEventSize;
		}

		return events;
		}

		SensorsTestSharedMemory::SensorsTestSharedMemory(SharedMemType type, size_t size)
		: mType(type), mSize(0), mBuffer(nullptr) {
		native_handle_t* handle = nullptr;
		char* buffer = nullptr;
		switch (type) {
		case SharedMemType::ASHMEM: {
		int fd;
		handle = ::native_handle_create(1 /nFds/, 0 /nInts/);
		if (handle != nullptr) {
		handle->data[0] = fd = ::ashmem_create_region("SensorsTestSharedMemory", size);
		if (handle->data[0] > 0) {
		// memory is pinned by default
		buffer = static_cast<char*>(
		::mmap(NULL, size, PROT_READ \| PROT_WRITE, MAP_SHARED, fd, 0));
		if (buffer != reinterpret_cast<char*>(MAP_FAILED)) {
		break;
		}
		::native_handle_close(handle);
		}
		::native_handle_delete(handle);
		handle = nullptr;
		}
		break;
		}
		case SharedMemType::GRALLOC: {
		mGrallocWrapper = std::make_unique<::android::GrallocWrapper>();
		if (mGrallocWrapper->getAllocator() == nullptr \|\|
		mGrallocWrapper->getMapper() == nullptr) {
		break;
		}
		using android::hardware::graphics::common::V1_0::BufferUsage;
		using android::hardware::graphics::common::V1_0::PixelFormat;
		mapper2::IMapper::BufferDescriptorInfo buf_desc_info = {
		.width = static_cast<uint32_t>(size),
		.height = 1,
		.layerCount = 1,
		.usage = static_cast<uint64_t>(BufferUsage::SENSOR_DIRECT_DATA \|
		BufferUsage::CPU_READ_OFTEN),
		.format = PixelFormat::BLOB};

		handle = const_cast<native_handle_t*>(mGrallocWrapper->allocate(buf_desc_info));
		if (handle != nullptr) {
		mapper2::IMapper::Rect region{0, 0, static_cast<int32_t>(buf_desc_info.width),
		static_cast<int32_t>(buf_desc_info.height)};
		buffer = static_cast<char*>(
		mGrallocWrapper->lock(handle, buf_desc_info.usage, region, /fence=/-1));
		if (buffer != nullptr) {
		break;
		}
		mGrallocWrapper->freeBuffer(handle);
		handle = nullptr;
		}
		break;
		}
		default:
		break;
		}

		if (buffer != nullptr) {
		mNativeHandle = handle;
		mSize = size;
		mBuffer = buffer;
		}
		}

		SensorsTestSharedMemory::~SensorsTestSharedMemory() {
		switch (mType) {
		case SharedMemType::ASHMEM: {
		if (mSize != 0) {
		::munmap(mBuffer, mSize);
		mBuffer = nullptr;

		::native_handle_close(mNativeHandle);
		::native_handle_delete(mNativeHandle);

		mNativeHandle = nullptr;
		mSize = 0;
		}
		break;
		}
		case SharedMemType::GRALLOC: {
		if (mSize != 0) {
		mGrallocWrapper->unlock(mNativeHandle);
		mGrallocWrapper->freeBuffer(mNativeHandle);

		mNativeHandle = nullptr;
		mSize = 0;
		}
		break;
		}
		default: {
		if (mNativeHandle != nullptr \|\| mSize != 0 \|\| mBuffer != nullptr) {
		ALOGE(
		"SensorsTestSharedMemory %p not properly destructed: "
		"type %d, native handle %p, size %zu, buffer %p",
		this, static_cast<int>(mType), mNativeHandle, mSize, mBuffer);
		}
		break;
		}
		}
		}

		SensorsTestSharedMemory* SensorsTestSharedMemory::create(SharedMemType type, size_t size) {
		constexpr size_t kMaxSize = 128 * 1024 * 1024; // sensor test should not need more than 128M
		if (size == 0 \|\| size >= kMaxSize) {
		return nullptr;
		}

		auto m = new SensorsTestSharedMemory(type, size);
		if (m->mSize != size \|\| m->mBuffer == nullptr) {
		delete m;
		m = nullptr;
		}
		return m;
		}

sensors/common/vts/utils/include/sensors-vts-utils/SensorsTestSharedMemory.h

0 → 100644

+51 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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.
		*/

		#ifndef ANDROID_SENSORS_TEST_SHARED_MEMORY_H
		#define ANDROID_SENSORS_TEST_SHARED_MEMORY_H

		#include "GrallocWrapper.h"

		#include <android-base/macros.h>
		#include <android/hardware/sensors/1.0/types.h>

		#include <cutils/ashmem.h>

		class SensorsTestSharedMemory {
		using SharedMemType = ::android::hardware::sensors::V1_0::SharedMemType;
		using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo;
		using Event = ::android::hardware::sensors::V1_0::Event;

		public:
		static SensorsTestSharedMemory* create(SharedMemType type, size_t size);
		SharedMemInfo getSharedMemInfo() const;
		char* getBuffer() const;
		std::vector<Event> parseEvents(int64_t lastCounter = -1, size_t offset = 0) const;
		virtual ~SensorsTestSharedMemory();

		private:
		SensorsTestSharedMemory(SharedMemType type, size_t size);

		SharedMemType mType;
		native_handle_t* mNativeHandle;
		size_t mSize;
		char* mBuffer;
		std::unique_ptr<::android::GrallocWrapper> mGrallocWrapper;

		DISALLOW_COPY_AND_ASSIGN(SensorsTestSharedMemory);
		};

		#endif // ANDROID_SENSORS_TEST_SHARED_MEMORY_H