Merge "Initial libmemtrack" into klp-dev (c0ce002a) · Commits · e / os / android_system_core

libmemtrack/Android.mk

0 → 100644

+20 −0

Original line number	Diff line number	Diff line
		# Copyright 2013 The Android Open Source Project

		LOCAL_PATH:= $(call my-dir)

		include $(CLEAR_VARS)
		LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
		LOCAL_SRC_FILES := memtrack.c
		LOCAL_MODULE := libmemtrack
		LOCAL_C_INCLUDES += $(LOCAL_PATH)/include hardware/libhardware/include
		LOCAL_SHARED_LIBRARIES := libhardware liblog
		LOCAL_CFLAGS := -Wall -Werror
		include $(BUILD_SHARED_LIBRARY)

		include $(CLEAR_VARS)
		LOCAL_SRC_FILES := memtrack_test.c
		LOCAL_MODULE := memtrack_test
		LOCAL_C_INCLUDES := $(call include-path-for, libpagemap)
		LOCAL_SHARED_LIBRARIES := libmemtrack libpagemap
		LOCAL_CFLAGS := -Wall -Werror
		include $(BUILD_EXECUTABLE)

libmemtrack/include/memtrack.h

0 → 100644

+138 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2013 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 _LIBMEMTRACK_MEMTRACK_H_
		#define _LIBMEMTRACK_MEMTRACK_H_

		#include <sys/types.h>
		#include <stddef.h>

		/**
		* struct memtrack_proc
		*
		* an opaque handle to the memory stats on a process.
		* Created with memtrack_proc_new, destroyed by
		* memtrack_proc_destroy. Can be reused multiple times with
		* memtrack_proc_get.
		*/
		struct memtrack_proc;

		/**
		* memtrack_init
		*
		* Must be called once before calling any other functions. After this function
		* is called, everything else is thread-safe.
		*
		* Returns 0 on success, -errno on error.
		*/
		int memtrack_init(void);

		/**
		* memtrack_proc_new
		*
		* Return a new handle to hold process memory stats.
		*
		* Returns NULL on error.
		*/
		struct memtrack_proc *memtrack_proc_new(void);

		/**
		* memtrack_proc_destroy
		*
		* Free all memory associated with a process memory stats handle.
		*/
		void memtrack_proc_destroy(struct memtrack_proc *p);

		/**
		* memtrack_proc_get
		*
		* Fill a process memory stats handle with data about the given pid. Can be
		* called on a handle that was just allocated with memtrack_proc_new,
		* or on a handle that has been previously passed to memtrack_proc_get
		* to replace the data with new data on the same or another process. It is
		* expected that the second call on the same handle should not require
		* allocating any new memory.
		*
		* Returns 0 on success, -errno on error.
		*/
		int memtrack_proc_get(struct memtrack_proc *p, pid_t pid);

		/**
		* memtrack_proc_graphics_total
		*
		* Return total amount of memory that has been allocated for use as window
		* buffers. Does not differentiate between memory that has already been
		* accounted for by reading /proc/pid/smaps and memory that has not been
		* accounted for.
		*
		* Returns non-negative size in bytes on success, -errno on error.
		*/
		ssize_t memtrack_proc_graphics_total(struct memtrack_proc *p);

		/**
		* memtrack_proc_graphics_pss
		*
		* Return total amount of memory that has been allocated for use as window
		* buffers, but has not already been accounted for by reading /proc/pid/smaps.
		* Memory that is shared across processes may already be divided by the
		* number of processes that share it (preferred), or may be charged in full to
		* every process that shares it, depending on the capabilities of the driver.
		*
		* Returns non-negative size in bytes on success, -errno on error.
		*/
		ssize_t memtrack_proc_graphics_pss(struct memtrack_proc *p);

		/**
		* memtrack_proc_gl_total
		*
		* Same as memtrack_proc_graphics_total, but counts GL memory (which
		* should not overlap with graphics memory) instead of graphics memory.
		*
		* Returns non-negative size in bytes on success, -errno on error.
		*/
		ssize_t memtrack_proc_gl_total(struct memtrack_proc *p);

		/**
		* memtrack_proc_gl_pss
		*
		* Same as memtrack_proc_graphics_total, but counts GL memory (which
		* should not overlap with graphics memory) instead of graphics memory.
		*
		* Returns non-negative size in bytes on success, -errno on error.
		*/
		ssize_t memtrack_proc_gl_pss(struct memtrack_proc *p);

		/**
		* memtrack_proc_gl_total
		*
		* Same as memtrack_proc_graphics_total, but counts miscellaneous memory
		* not tracked by gl or graphics calls above.
		*
		* Returns non-negative size in bytes on success, -errno on error.
		*/
		ssize_t memtrack_proc_other_total(struct memtrack_proc *p);

		/**
		* memtrack_proc_gl_pss
		*
		* Same as memtrack_proc_graphics_total, but counts miscellaneous memory
		* not tracked by gl or graphics calls above.
		*
		* Returns non-negative size in bytes on success, -errno on error.
		*/
		ssize_t memtrack_proc_other_pss(struct memtrack_proc *p);

		#endif

libmemtrack/memtrack.c

0 → 100644

+200 −0

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

		#define LOG_TAG "memtrack"

		#include <log/log.h>

		#include <hardware/memtrack.h>

		#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))

		static const memtrack_module_t *module;

		struct memtrack_proc {
		pid_t pid;
		struct memtrack_proc_type {
		enum memtrack_type type;
		size_t num_records;
		size_t allocated_records;
		struct memtrack_record *records;
		} types[MEMTRACK_NUM_TYPES];
		};

		int memtrack_init(void)
		{
		int err;

		if (module) {
		return 0;
		}

		err = hw_get_module(MEMTRACK_HARDWARE_MODULE_ID,
		(hw_module_t const**)&module);
		if (err) {
		ALOGE("Couldn't load %s module (%s)", MEMTRACK_HARDWARE_MODULE_ID,
		strerror(-err));
		return err;
		}

		return module->init(module);
		}

		struct memtrack_proc *memtrack_proc_new(void)
		{
		if (!module) {
		return NULL;
		}

		return calloc(sizeof(struct memtrack_proc), 1);
		}

		void memtrack_proc_destroy(struct memtrack_proc *p)
		{
		enum memtrack_type i;

		if (p) {
		for (i = 0; i < MEMTRACK_NUM_TYPES; i++) {
		free(p->types[i].records);
		}
		}
		free(p);
		}

		static int memtrack_proc_get_type(struct memtrack_proc_type *t,
		pid_t pid, enum memtrack_type type)
		{
		size_t num_records = t->num_records;
		int ret;

		retry:
		ret = module->getMemory(module, pid, type, t->records, &num_records);
		if (ret) {
		t->num_records = 0;
		return ret;
		}
		if (num_records > t->allocated_records) {
		/* Need more records than allocated */
		free(t->records);
		t->records = calloc(sizeof(*t->records), num_records);
		if (!t->records) {
		return -ENOMEM;
		}
		t->allocated_records = num_records;
		goto retry;
		}
		t->num_records = num_records;

		return 0;
		}

		/* TODO: sanity checks on return values from HALs:
		* make sure no records have invalid flags set
		* - unknown flags
		* - too many flags of a single category
		* - missing ACCOUNTED/UNACCOUNTED
		* make sure there are not overlapping SHARED and SHARED_PSS records
		*/
		static int memtrack_proc_sanity_check(struct memtrack_proc *p)
		{
		(void)p;
		return 0;
		}

		int memtrack_proc_get(struct memtrack_proc *p, pid_t pid)
		{
		enum memtrack_type i;

		if (!module) {
		return -EINVAL;
		}

		if (!p) {
		return -EINVAL;
		}

		p->pid = pid;
		for (i = 0; i < MEMTRACK_NUM_TYPES; i++) {
		memtrack_proc_get_type(&p->types[i], pid, i);
		}

		return memtrack_proc_sanity_check(p);
		}

		static ssize_t memtrack_proc_sum(struct memtrack_proc *p,
		enum memtrack_type types[], size_t num_types,
		unsigned int flags)
		{
		ssize_t sum = 0;
		size_t i;
		size_t j;

		for (i = 0; i < num_types; i++) {
		enum memtrack_type type = types[i];
		for (j = 0; j < p->types[type].num_records; j++) {
		if ((p->types[type].records[j].flags & flags) == flags) {
		sum += p->types[type].records[j].size_in_bytes;
		}
		}
		}

		return sum;
		}

		ssize_t memtrack_proc_graphics_total(struct memtrack_proc *p)
		{
		enum memtrack_type types[] = { MEMTRACK_TYPE_GRAPHICS };
		return memtrack_proc_sum(p, types, ARRAY_SIZE(types), 0);
		}

		ssize_t memtrack_proc_graphics_pss(struct memtrack_proc *p)
		{
		enum memtrack_type types[] = { MEMTRACK_TYPE_GRAPHICS };
		return memtrack_proc_sum(p, types, ARRAY_SIZE(types),
		MEMTRACK_FLAG_SMAPS_UNACCOUNTED);
		}

		ssize_t memtrack_proc_gl_total(struct memtrack_proc *p)
		{
		enum memtrack_type types[] = { MEMTRACK_TYPE_GL };
		return memtrack_proc_sum(p, types, ARRAY_SIZE(types), 0);
		}

		ssize_t memtrack_proc_gl_pss(struct memtrack_proc *p)
		{
		enum memtrack_type types[] = { MEMTRACK_TYPE_GL };
		return memtrack_proc_sum(p, types, ARRAY_SIZE(types),
		MEMTRACK_FLAG_SMAPS_UNACCOUNTED);
		}

		ssize_t memtrack_proc_other_total(struct memtrack_proc *p)
		{
		enum memtrack_type types[] = { MEMTRACK_TYPE_MULTIMEDIA,
		MEMTRACK_TYPE_CAMERA,
		MEMTRACK_TYPE_OTHER };
		return memtrack_proc_sum(p, types, ARRAY_SIZE(types), 0);
		}

		ssize_t memtrack_proc_other_pss(struct memtrack_proc *p)
		{
		enum memtrack_type types[] = { MEMTRACK_TYPE_MULTIMEDIA,
		MEMTRACK_TYPE_CAMERA,
		MEMTRACK_TYPE_OTHER };
		return memtrack_proc_sum(p, types, ARRAY_SIZE(types),
		MEMTRACK_FLAG_SMAPS_UNACCOUNTED);
		}

libmemtrack/memtrack_test.c

0 → 100644

+145 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2013 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 <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		#include <sys/types.h>

		#include <memtrack.h>

		#include <pagemap/pagemap.h>

		#define DIV_ROUND_UP(x,y) (((x) + (y) - 1) / (y))

		static int getprocname(pid_t pid, char *buf, int len) {
		char *filename;
		FILE *f;
		int rc = 0;
		static const char* unknown_cmdline = "<unknown>";

		if (len <= 0) {
		return -1;
		}

		if (asprintf(&filename, "/proc/%zd/cmdline", pid) < 0) {
		rc = 1;
		goto exit;
		}

		f = fopen(filename, "r");
		if (f == NULL) {
		rc = 2;
		goto releasefilename;
		}

		if (fgets(buf, len, f) == NULL) {
		rc = 3;
		goto closefile;
		}

		closefile:
		(void) fclose(f);
		releasefilename:
		free(filename);
		exit:
		if (rc != 0) {
		/*
		* The process went away before we could read its process name. Try
		* to give the user "<unknown>" here, but otherwise they get to look
		* at a blank.
		*/
		if (strlcpy(buf, unknown_cmdline, (size_t)len) >= (size_t)len) {
		rc = 4;
		}
		}

		return rc;
		}

		int main(int argc, char *argv[])
		{
		int ret;
		pm_kernel_t *ker;
		size_t num_procs;
		pid_t *pids;
		struct memtrack_proc *p;
		size_t i;

		(void)argc;
		(void)argv;

		ret = memtrack_init();
		if (ret < 0) {
		fprintf(stderr, "failed to initialize HAL: %s (%d)\n", strerror(-ret), ret);
		exit(EXIT_FAILURE);
		}

		ret = pm_kernel_create(&ker);
		if (ret) {
		fprintf(stderr, "Error creating kernel interface -- "
		"does this kernel have pagemap?\n");
		exit(EXIT_FAILURE);
		}

		ret = pm_kernel_pids(ker, &pids, &num_procs);
		if (ret) {
		fprintf(stderr, "Error listing processes.\n");
		exit(EXIT_FAILURE);
		}

		p = memtrack_proc_new();
		if (ret) {
		fprintf(stderr, "failed to create memtrack process handle\n");
		exit(EXIT_FAILURE);
		}

		for (i = 0; i < num_procs; i++) {
		pid_t pid = pids[i];
		char cmdline[256];
		size_t v1;
		size_t v2;
		size_t v3;
		size_t v4;
		size_t v5;
		size_t v6;

		getprocname(pid, cmdline, (int)sizeof(cmdline));

		ret = memtrack_proc_get(p, pid);
		if (ret) {
		fprintf(stderr, "failed to get memory info for pid %d: %s (%d)\n",
		pid, strerror(-ret), ret);
		continue;
		}

		v1 = DIV_ROUND_UP(memtrack_proc_graphics_total(p), 1024);
		v2 = DIV_ROUND_UP(memtrack_proc_graphics_pss(p), 1024);
		v3 = DIV_ROUND_UP(memtrack_proc_gl_total(p), 1024);
		v4 = DIV_ROUND_UP(memtrack_proc_gl_pss(p), 1024);
		v5 = DIV_ROUND_UP(memtrack_proc_other_total(p), 1024);
		v6 = DIV_ROUND_UP(memtrack_proc_other_pss(p), 1024);

		if (v1 \| v2 \| v3 \| v4 \| v5 \| v6) {
		printf("%5d %6zu %6zu %6zu %6zu %6zu %6zu %s\n", pid,
		v1, v2, v3, v4, v5, v6, cmdline);
		}
		}

		memtrack_proc_destroy(p);

		return 0;
		}