GPU Memory: implement libgpumem to interact with bpf am: 380893053e am: da50cb0e10 am: 35e1ef826a (8dc08559) · Commits · e / os / android_frameworks_native-old

services/gpuservice/gpumem/Android.bp

0 → 100644

+41 −0

Original line number	Diff line number	Diff line
		// Copyright 2020 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.

		cc_library_shared {
		name: "libgpumem",
		srcs: [
		"GpuMem.cpp",
		],
		shared_libs: [
		"libbase",
		"libbpf",
		"libbpf_android",
		"libcutils",
		"liblog",
		"libutils",
		],
		export_include_dirs: ["include"],
		export_shared_lib_headers: [
		"libbase",
		"libbpf_android",
		],
		cppflags: [
		"-Wall",
		"-Werror",
		"-Wformat",
		"-Wthread-safety",
		"-Wunused",
		"-Wunreachable-code",
		],
		}

services/gpuservice/gpumem/GpuMem.cpp

0 → 100644

+123 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2020 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.
		*/

		#undef LOG_TAG
		#define LOG_TAG "GpuMem"
		#define ATRACE_TAG ATRACE_TAG_GRAPHICS

		#include "gpumem/GpuMem.h"

		#include <android-base/stringprintf.h>
		#include <libbpf.h>
		#include <libbpf_android.h>
		#include <log/log.h>
		#include <utils/Trace.h>

		#include <unordered_map>
		#include <vector>

		namespace android {

		using base::StringAppendF;

		GpuMem::~GpuMem() {
		bpf_detach_tracepoint(kGpuMemTraceGroup, kGpuMemTotalTracepoint);
		}

		void GpuMem::initialize() {
		// Make sure bpf programs are loaded
		bpf::waitForProgsLoaded();

		int fd = bpf::bpfFdGet(kGpuMemTotalProgPath, BPF_F_RDONLY);
		if (fd < 0) {
		ALOGE("Failed to retrieve pinned program from %s", kGpuMemTotalProgPath);
		return;
		}

		// Attach the program to the tracepoint, and the tracepoint is automatically enabled here.
		if (bpf_attach_tracepoint(fd, kGpuMemTraceGroup, kGpuMemTotalTracepoint) < 0) {
		ALOGE("Failed to attach bpf program to %s/%s tracepoint", kGpuMemTraceGroup,
		kGpuMemTotalTracepoint);
		return;
		}

		// Use the read-only wrapper BpfMapRO to properly retrieve the read-only map.
		auto map = bpf::BpfMapRO<uint64_t, uint64_t>(kGpuMemTotalMapPath);
		if (!map.isValid()) {
		ALOGE("Failed to create bpf map from %s", kGpuMemTotalMapPath);
		return;
		}
		setGpuMemTotalMap(map);
		}

		void GpuMem::setGpuMemTotalMap(bpf::BpfMap<uint64_t, uint64_t>& map) {
		mGpuMemTotalMap = std::move(map);
		}

		// Dump the snapshots of global and per process memory usage on all gpus
		void GpuMem::dump(const Vector<String16>& /* args /, std::string result) {
		ATRACE_CALL();

		if (!mGpuMemTotalMap.isValid()) {
		result->append("Failed to initialize GPU memory eBPF\n");
		return;
		}

		auto res = mGpuMemTotalMap.getFirstKey();
		if (!res.ok()) {
		result->append("GPU memory total usage map is empty\n");
		return;
		}
		uint64_t key = res.value();
		// unordered_map<gpu_id, vector<pair<pid, size>>>
		std::unordered_map<uint32_t, std::vector<std::pair<uint32_t, uint64_t>>> dumpMap;
		while (true) {
		uint32_t gpu_id = key >> 32;
		uint32_t pid = key;

		res = mGpuMemTotalMap.readValue(key);
		if (!res.ok()) break;
		uint64_t size = res.value();

		dumpMap[gpu_id].emplace_back(pid, size);

		res = mGpuMemTotalMap.getNextKey(key);
		if (!res.ok()) break;
		key = res.value();
		}

		for (auto& gpu : dumpMap) {
		if (gpu.second.empty()) continue;
		StringAppendF(result, "Memory snapshot for GPU %u:\n", gpu.first);

		std::sort(gpu.second.begin(), gpu.second.end(),
		[](auto& l, auto& r) { return l.first < r.first; });

		int i = 0;
		if (gpu.second[0].first != 0) {
		StringAppendF(result, "Global total: N/A\n");
		} else {
		StringAppendF(result, "Global total: %" PRIu64 "\n", gpu.second[0].second);
		i++;
		}
		for (; i < gpu.second.size(); i++) {
		StringAppendF(result, "Proc %u total: %" PRIu64 "\n", gpu.second[i].first,
		gpu.second[i].second);
		}
		}
		}

		} // namespace android

services/gpuservice/gpumem/include/gpumem/GpuMem.h

0 → 100644

+56 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2020 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.
		*/

		#pragma once

		#include <bpf/BpfMap.h>
		#include <utils/String16.h>
		#include <utils/Vector.h>

		namespace android {

		class GpuMem {
		public:
		GpuMem() = default;
		~GpuMem();

		// initialize eBPF program and map
		void initialize();
		// dumpsys interface
		void dump(const Vector<String16>& args, std::string* result);

		private:
		// Friend class for testing.
		friend class TestableGpuMem;

		// set gpu memory total map
		void setGpuMemTotalMap(bpf::BpfMap<uint64_t, uint64_t>& map);

		// bpf map for GPU memory total data
		android::bpf::BpfMap<uint64_t, uint64_t> mGpuMemTotalMap;

		// gpu memory tracepoint event category
		static constexpr char kGpuMemTraceGroup[] = "gpu_mem";
		// gpu memory total tracepoint
		static constexpr char kGpuMemTotalTracepoint[] = "gpu_mem_total";
		// pinned gpu memory total bpf c program path in bpf sysfs
		static constexpr char kGpuMemTotalProgPath[] =
		"/sys/fs/bpf/prog_gpu_mem_tracepoint_gpu_mem_gpu_mem_total";
		// pinned gpu memory total bpf map path in bpf sysfs
		static constexpr char kGpuMemTotalMapPath[] = "/sys/fs/bpf/map_gpu_mem_gpu_mem_total_map";
		};

		} // namespace android