mspdebug/ui/power.c

/* MSPDebug - debugging tool MSP430 MCUs
 * Copyright (C) 2009-2012 Daniel Beer
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "util.h"
#include "stab.h"
#include "output.h"
#include "output_util.h"
#include "device.h"
#include "power.h"
#include "powerbuf.h"

static void print_header(powerbuf_t pb, unsigned int s)
{
	unsigned int length;
	const struct powerbuf_session *rec =
		powerbuf_session_info(pb, s, &length);

	printc("Session #%d: %s", s, ctime(&rec->wall_clock));
	printc("%d samples (spanning %.03f ms)\n",
		length, (double)(length * pb->interval_us) / 1000.0);
	printc("%.01f uA average (%.01f uAs total charge)\n",
		(double)rec->total_ua / (double)length,
		(double)(rec->total_ua * pb->interval_us) / 1000000.0);
}

static void dump_session_data(powerbuf_t pb, unsigned int s,
			      unsigned int gran)
{
	unsigned int length;
	const struct powerbuf_session *rec =
		powerbuf_session_info(pb, s, &length);
	unsigned int i;
	int idx;

	print_header(pb, s);
	printc("\n");

	printc("%15s %15s %-15s\n", "Time (us)", "Current (uA)", "MAB");
	printc("------------------------------------------------\n");

	idx = rec->start_index;

	for (i = 0; i + gran <= length; i += gran) {
		address_t mab = pb->mab[idx];
		unsigned long ua_tot = 0;
		char addr[128];
		int j;

		for (j = 0; j < gran; j++) {
			ua_tot += pb->current_ua[idx];
			idx = (idx + 1) % pb->max_samples;
		}

		print_address(mab, addr, sizeof(addr), 0);
		printc("%15d %15.01f %s\n", i * pb->interval_us,
			((double)ua_tot) / (double)gran, addr);
	}

	printc("\n");
}

static int sc_info(powerbuf_t pb)
{
	int sess_num = powerbuf_num_sessions(pb);
	int i;

	printc("Sample granularity is %d us\n", pb->interval_us);
	printc("%d sessions:\n", sess_num);

	for (i = sess_num - 1; i >= 0; i--) {
		printc("\n");
		print_header(pb, i);
	}

	return 0;
}

static int sc_clear(powerbuf_t pb)
{
	powerbuf_clear(pb);
	return 0;
}

static int parse_granularity(powerbuf_t pb, char **arg, int *gran_out)
{
	const char *text = get_arg(arg);
	int request = 10000;
	int gran;

	if (text)
		request = atoi(text);

	if (request <= 0) {
		printc_err("power: invalid granularity: %d us\n", request);
		return -1;
	}

	gran = (request + (pb->interval_us / 2)) / pb->interval_us;

	if (gran <= 0)
		gran = 1;

	*gran_out = gran;
	return 0;
}

static int sc_all(powerbuf_t pb, char **arg)
{
	int i;
	int gran;

	if (parse_granularity(pb, arg, &gran) < 0)
		return -1;

	for (i = powerbuf_num_sessions(pb) - 1; i >= 0; i--)
		dump_session_data(pb, i, gran);

	return 0;
}

static int sc_session(powerbuf_t pb, char **arg)
{
	const char *sess_text = get_arg(arg);
	int sess;
	int gran;

	if (!sess_text) {
		printc_err("power: you must specify a session number\n");
		return -1;
	}

	sess = atoi(sess_text);
	if (sess < 0 || sess >= powerbuf_num_sessions(pb)) {
		printc_err("power: invalid session: %d\n", sess);
		return -1;
	}

	if (parse_granularity(pb, arg, &gran) < 0)
		return -1;

	dump_session_data(pb, sess, gran);
	return 0;
}

static int sc_export_csv(powerbuf_t pb, char **arg)
{
	const char *sess_text = get_arg(arg);
	const char *filename = get_arg(arg);
	unsigned int length;
	const struct powerbuf_session *rec;
	FILE *out;
	int sess;
	unsigned int i;

	if (!(sess_text && filename)) {
		printc_err("power: expected a session number and filename\n");
		return -1;
	}

	sess = atoi(sess_text);
	if (sess < 0 || sess >= powerbuf_num_sessions(pb)) {
		printc_err("power: invalid session: %d\n", sess);
		return -1;
	}

	rec = powerbuf_session_info(pb, sess, &length);

	out = fopen(filename, "w");
	if (!out) {
		printc_err("power: can't open %s: %s\n",
			   filename, last_error());
		return -1;
	}

	for (i = 0; i < length; i++) {
		const unsigned int idx =
			(rec->start_index + i) % pb->max_samples;

		if (fprintf(out, "%15d,%15d, 0x%05x\n",
			    i * pb->interval_us,
			    pb->current_ua[idx], pb->mab[idx]) < 0) {
			printc_err("power: write error: %s: %s\n",
				   filename, last_error());
			fclose(out);
			return -1;
		}
	}

	if (fclose(out) < 0) {
		printc_err("power: error on close of %s: %s\n",
			    filename, last_error());
		return -1;
	}

	printc("Exported %d samples to %s\n", length, filename);
	return 0;
}

struct profile_rec {
	char			name[64];
	address_t		addr;
	unsigned long long	charge;
	int			samples;
};

static int add_symbol(void *user_data, const char *name, address_t offset)
{
	struct vector *v = (struct vector *)user_data;
	struct profile_rec rec;

	strncpy(rec.name, name, sizeof(rec.name));
	rec.name[sizeof(rec.name) - 1] = 0;

	rec.addr = offset;
	rec.charge = 0;
	rec.samples = 0;

	return vector_push(v, &rec, 1);
}

static void merge_power(struct vector *list, powerbuf_t pb)
{
	int num_samples =
		(pb->current_head + pb->max_samples - pb->current_tail) %
			pb->max_samples;
	int dst = 0;
	int src = 0;

	/* Skip samples that don't match any known symbol */
	while ((dst < list->size) && (src < num_samples) &&
	       (pb->mab[pb->sorted[src]] <
		VECTOR_PTR(*list, dst, struct profile_rec)->addr))
		src++;

	while ((dst < list->size) && (src < num_samples)) {
		address_t mab = pb->mab[pb->sorted[src]];
		unsigned int ua = pb->current_ua[pb->sorted[src]];

		if ((dst + 1 < list->size) &&
		    (VECTOR_PTR(*list, dst + 1,
				struct profile_rec)->addr <= mab)) {
			dst++;
		} else {
			struct profile_rec *r =
				VECTOR_PTR(*list, dst, struct profile_rec);

			r->charge += ua;
			r->samples++;
			src++;
		}
	}
}

static int cmp_by_addr(const void *a, const void *b)
{
	const struct profile_rec *pa = (const struct profile_rec *)a;
	const struct profile_rec *pb = (const struct profile_rec *)b;

	if (pa->addr < pb->addr)
		return -1;
	if (pa->addr > pb->addr)
		return 1;

	return 0;
}

static int cmp_by_charge_rev(const void *a, const void *b)
{
	const struct profile_rec *pa = (const struct profile_rec *)a;
	const struct profile_rec *pb = (const struct profile_rec *)b;

	if (pa->charge < pb->charge)
		return 1;
	if (pa->charge > pb->charge)
		return -1;

	return 0;
}

static void print_profile(int interval_us, const struct vector *list)
{
	int i;

	printc("%-7s %-15s %15s %15s %15s\n",
		"Addr", "Name", "Charge (uAs)", "Time (ms)", "Current (uA)");
	printc("---------------------------------------"
	       "---------------------------------\n");

	for (i = 0; i < list->size; i++) {
		const struct profile_rec *r =
			VECTOR_PTR(*list, i, const struct profile_rec);

		if (!r->samples)
			continue;

		printc("0x%05x %-15s %15.01f %15.01f %15.01f\n",
			r->addr, r->name,
			(double)(r->charge * interval_us) / 1000000.0,
			(double)(r->samples * interval_us) / 1000.0,
			(double)r->charge / (double)r->samples);
	}
}

static int sc_profile(powerbuf_t pb)
{
	struct vector list;

	/* First, assemble a list of symbols */
	vector_init(&list, sizeof(struct profile_rec));
	if (stab_enum(add_symbol, &list) < 0) {
		printc_err("Out of memory: %s\n", last_error());
		vector_destroy(&list);
		return -1;
	}

	/* Merge in power profile samples */
	qsort(list.ptr, list.size, list.elemsize, cmp_by_addr);
	powerbuf_sort(pb);
	merge_power(&list, pb);

	/* Prepare and print profile */
	qsort(list.ptr, list.size, list.elemsize, cmp_by_charge_rev);
	print_profile(pb->interval_us, &list);
	vector_destroy(&list);

	return 0;
}

int cmd_power(char **arg)
{
	powerbuf_t pb = device_default->power_buf;
	char *subcmd = get_arg(arg);

	if (!pb) {
		printc_err("power: power profiling is not supported "
			   "by this device.\n");
		return -1;
	}

	if (!subcmd) {
		printc_err("power: need to specify a subcommand "
			   "(try \"help power\")\n");
		return -1;
	}

	if (!strcasecmp(subcmd, "info"))
		return sc_info(pb);
	if (!strcasecmp(subcmd, "clear"))
		return sc_clear(pb);
	if (!strcasecmp(subcmd, "all"))
		return sc_all(pb, arg);
	if (!strcasecmp(subcmd, "session"))
		return sc_session(pb, arg);
	if (!strcasecmp(subcmd, "export-csv"))
		return sc_export_csv(pb, arg);
	if (!strcasecmp(subcmd, "profile"))
		return sc_profile(pb);

	printc_err("power: unknown subcommand: %s (try \"help power\")\n",
		   subcmd);
	return -1;
}