Hosted/linux: Add process/cpu info screen to the debug menu.
The new menu is very helpful on RaaA, but also shown in the sim. It shows the process cpu usage, process' time stats (user,sys,real) and the cpu frequency stats. It uses a thread to sample the data, however the thread is not created until the menu is visited for the first time. git-svn-id: svn://svn.rockbox.org/rockbox/trunk@31364 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Thomas Martitz
parent
f53c04b766
commit
287454de2e
|
|
@ -7,13 +7,19 @@
|
|||
# $Id$
|
||||
#
|
||||
|
||||
# this is a glibc compatibility hack to provide a get_nprocs() replacement.
|
||||
# The NDK ships cpu-features.c which has a compatible function android_getCpuCount()
|
||||
CPUFEAT = /home/kugel/share/android-ndk-r6/sources/android/cpufeatures
|
||||
INCLUDES += -I$(CPUFEAT)
|
||||
OTHER_SRC += $(CPUFEAT)/cpu-features.c
|
||||
$(BUILDDIR)/cpu-features.o: $(CPUFEAT)/cpu-features.c
|
||||
$(call PRINTS,CC $(subst $(ANDROID_NDK_PATH)/,,$<))$(CC) -o $@ -c $^ \
|
||||
$(GCCOPTS) -Wno-unused
|
||||
|
||||
.SECONDEXPANSION: # $$(JAVA_OBJ) is not populated until after this
|
||||
.SECONDEXPANSION: # $$(OBJ) is not populated until after this
|
||||
.PHONY: apk classes clean dex dirs libs jar
|
||||
|
||||
$(BUILDDIR)/$(BINARY): $$(OBJ) $(VOICESPEEXLIB) $(FIRMLIB) $(SKINLIB)
|
||||
$(call PRINTS,LD $(BINARY))$(CC) -o $@ $^ $(LDOPTS) $(GLOBAL_LDOPTS)
|
||||
|
||||
PACKAGE=org.rockbox
|
||||
PACKAGE_PATH=org/rockbox
|
||||
ANDROID_DIR=$(ROOTDIR)/android
|
||||
|
|
@ -103,6 +109,10 @@ dex: $(DEX)
|
|||
|
||||
classes: $(R_OBJ) $(JAVA_OBJ)
|
||||
|
||||
|
||||
$(BUILDDIR)/$(BINARY): $$(OBJ) $(VOICESPEEXLIB) $(FIRMLIB) $(SKINLIB) $(BUILDDIR)/cpu-features.o
|
||||
$(call PRINTS,LD $(BINARY))$(CC) -o $@ $^ $(LDOPTS) $(GLOBAL_LDOPTS)
|
||||
|
||||
$(BINLIB_DIR)/$(BINARY): $(BUILDDIR)/$(BINARY)
|
||||
$(call PRINTS,CP $(BINARY))cp $^ $@
|
||||
|
||||
|
|
|
|||
|
|
@ -232,6 +232,108 @@ static bool dbg_os(void)
|
|||
return simplelist_show_list(&info);
|
||||
}
|
||||
|
||||
#ifdef __linux__
|
||||
#include "cpuinfo-linux.h"
|
||||
|
||||
#define MAX_STATES 16
|
||||
static struct time_state states[MAX_STATES];
|
||||
|
||||
static const char* get_cpuinfo(int selected_item, void *data,
|
||||
char *buffer, size_t buffer_len)
|
||||
{
|
||||
(void)data;(void)buffer_len;
|
||||
const char* text;
|
||||
long time, diff;
|
||||
struct cpuusage us;
|
||||
static struct cpuusage last_us;
|
||||
int state_count = *(int*)data;
|
||||
|
||||
if (cpuusage_linux(&us) != 0)
|
||||
return NULL;
|
||||
|
||||
switch(selected_item)
|
||||
{
|
||||
case 0:
|
||||
diff = abs(last_us.usage - us.usage);
|
||||
sprintf(buffer, "Usage: %ld.%02ld%% (%c %ld.%02ld)",
|
||||
us.usage/100, us.usage%100,
|
||||
(us.usage >= last_us.usage) ? '+':'-',
|
||||
diff/100, diff%100);
|
||||
last_us.usage = us.usage;
|
||||
return buffer;
|
||||
case 1:
|
||||
text = "User";
|
||||
time = us.utime;
|
||||
diff = us.utime - last_us.utime;
|
||||
last_us.utime = us.utime;
|
||||
break;
|
||||
case 2:
|
||||
text = "Sys";
|
||||
time = us.stime;
|
||||
diff = us.stime - last_us.stime;
|
||||
last_us.stime = us.stime;
|
||||
break;
|
||||
case 3:
|
||||
text = "Real";
|
||||
time = us.rtime;
|
||||
diff = us.rtime - last_us.rtime;
|
||||
last_us.rtime = us.rtime;
|
||||
break;
|
||||
case 4:
|
||||
return "*** Per CPU freq stats ***";
|
||||
default:
|
||||
{
|
||||
int cpu = (selected_item - 5) / (state_count + 1);
|
||||
int cpu_line = (selected_item - 5) % (state_count + 1);
|
||||
int freq1 = cpufrequency_linux(cpu);
|
||||
int freq2 = scalingfrequency_linux(cpu);
|
||||
if (cpu_line == 0)
|
||||
{
|
||||
sprintf(buffer, " CPU%d: Cur/Scal freq: %d/%d MHz", cpu,
|
||||
freq1 > 0 ? freq1/1000 : -1,
|
||||
freq2 > 0 ? freq2/1000 : -1);
|
||||
}
|
||||
else
|
||||
{
|
||||
cpustatetimes_linux(cpu, states, ARRAYLEN(states));
|
||||
snprintf(buffer, buffer_len, " %ld %ld",
|
||||
states[cpu_line-1].frequency,
|
||||
states[cpu_line-1].time);
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
}
|
||||
sprintf(buffer, "%s: %ld.%02lds (+ %ld.%02ld)", text,
|
||||
time / us.hz, time % us.hz,
|
||||
diff / us.hz, diff % us.hz);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
static int cpuinfo_cb(int action, struct gui_synclist *lists)
|
||||
{
|
||||
(void)lists;
|
||||
if (action == ACTION_NONE)
|
||||
action = ACTION_REDRAW;
|
||||
return action;
|
||||
}
|
||||
|
||||
static bool dbg_cpuinfo(void)
|
||||
{
|
||||
struct simplelist_info info;
|
||||
int cpu_count = MAX(cpucount_linux(), 1);
|
||||
int state_count = cpustatetimes_linux(0, states, ARRAYLEN(states));
|
||||
printf("%s(): %d %d\n", __func__, cpu_count, state_count);
|
||||
simplelist_info_init(&info, "CPU info:", 5 + cpu_count*(state_count+1), &state_count);
|
||||
info.get_name = get_cpuinfo;
|
||||
info.action_callback = cpuinfo_cb;
|
||||
info.timeout = HZ;
|
||||
info.hide_selection = true;
|
||||
info.scroll_all = true;
|
||||
return simplelist_show_list(&info);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_LCD_BITMAP
|
||||
#if CONFIG_CODEC != SWCODEC
|
||||
#ifndef SIMULATOR
|
||||
|
|
@ -2062,6 +2164,9 @@ static const struct the_menu_item menuitems[] = {
|
|||
{ "Catch mem accesses", dbg_set_memory_guard },
|
||||
#endif
|
||||
{ "View OS stacks", dbg_os },
|
||||
#ifdef __linux__
|
||||
{ "View CPU stats", dbg_cpuinfo },
|
||||
#endif
|
||||
#ifdef HAVE_LCD_BITMAP
|
||||
#if (CONFIG_PLATFORM & PLATFORM_NATIVE)
|
||||
{ "View battery", view_battery },
|
||||
|
|
@ -2187,4 +2292,3 @@ bool run_debug_screen(char* screen)
|
|||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,6 +7,12 @@ general.c
|
|||
load_code.c
|
||||
powermgmt.c
|
||||
#if (CONFIG_PLATFORM & PLATFORM_HOSTED)
|
||||
|
||||
#ifdef __linux__
|
||||
#undef linux
|
||||
target/hosted/cpuinfo-linux.c
|
||||
#endif
|
||||
|
||||
target/hosted/powermgmt.c
|
||||
target/hosted/rtc.c
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -0,0 +1,198 @@
|
|||
/***************************************************************************
|
||||
* __________ __ ___.
|
||||
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
||||
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
||||
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
||||
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
||||
* \/ \/ \/ \/ \/
|
||||
* $Id$
|
||||
*
|
||||
* Copyright (C) 2011 Thomas Martitz
|
||||
*
|
||||
* 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
||||
* KIND, either express or implied.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
|
||||
#include <sys/times.h>
|
||||
#include <sys/sysinfo.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include "kernel.h"
|
||||
#include "thread.h"
|
||||
#include "cpuinfo-linux.h"
|
||||
#include "gcc_extensions.h"
|
||||
|
||||
#undef open /* want the *real* open here, not sim_open or the like */
|
||||
#if (CONFIG_PLATFORM & PLATFORM_ANDROID)
|
||||
#include "cpu-features.h"
|
||||
#define get_nprocs android_getCpuCount
|
||||
#endif
|
||||
|
||||
#define NUM_SAMPLES 64
|
||||
#define NUM_SAMPLES_MASK (NUM_SAMPLES-1)
|
||||
#define SAMPLE_RATE 4
|
||||
|
||||
struct cputime_sample {
|
||||
struct tms sample;
|
||||
time_t time;
|
||||
};
|
||||
|
||||
static struct cputime_sample samples[NUM_SAMPLES];
|
||||
static int current_sample;
|
||||
static int samples_taken;
|
||||
static clock_t initial_time, hz;
|
||||
|
||||
|
||||
static char cputime_thread_stack[DEFAULT_STACK_SIZE + 0x100];
|
||||
static char cputime_thread_name[] = "cputime";
|
||||
static int cputime_threadid;
|
||||
static void cputime_thread(void);
|
||||
|
||||
/* times() can return -1 early after boot */
|
||||
static clock_t times_wrapper(struct tms *t)
|
||||
{
|
||||
clock_t res = times(t);
|
||||
if (res == (clock_t)-1)
|
||||
res = time(NULL) * hz;
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static inline void thread_func(void)
|
||||
{
|
||||
struct cputime_sample *s = &samples[current_sample++];
|
||||
s->time = times_wrapper(&s->sample);
|
||||
|
||||
current_sample &= NUM_SAMPLES_MASK;
|
||||
if (samples_taken < NUM_SAMPLES) samples_taken++;
|
||||
|
||||
sleep(HZ/SAMPLE_RATE);
|
||||
}
|
||||
|
||||
static void NORETURN_ATTR cputime_thread(void)
|
||||
{
|
||||
while(1)
|
||||
thread_func();
|
||||
}
|
||||
|
||||
static void __attribute__((constructor)) get_initial_time(void)
|
||||
{
|
||||
struct tms ign;
|
||||
hz = sysconf(_SC_CLK_TCK);
|
||||
initial_time = times_wrapper(&ign); /* dont pass NULL */;
|
||||
}
|
||||
|
||||
int cpuusage_linux(struct cpuusage* u)
|
||||
{
|
||||
if (UNLIKELY(!cputime_threadid))
|
||||
{
|
||||
/* collect some initial data and start the thread */
|
||||
thread_func();
|
||||
cputime_threadid = create_thread(cputime_thread, cputime_thread_stack,
|
||||
sizeof(cputime_thread_stack), 0, cputime_thread_name
|
||||
IF_PRIO(,PRIORITY_BACKGROUND) IF_COP(, CPU));
|
||||
}
|
||||
if (!u)
|
||||
return -1;
|
||||
|
||||
clock_t total_cputime;
|
||||
clock_t diff_utime, diff_stime;
|
||||
time_t diff_rtime;
|
||||
int latest_sample = ((current_sample == 0) ? NUM_SAMPLES : current_sample) - 1;
|
||||
int oldest_sample = (samples_taken < NUM_SAMPLES) ? 0 : current_sample;
|
||||
|
||||
diff_utime = samples[latest_sample].sample.tms_utime - samples[oldest_sample].sample.tms_utime;
|
||||
diff_stime = samples[latest_sample].sample.tms_stime - samples[oldest_sample].sample.tms_stime;
|
||||
diff_rtime = samples[latest_sample].time - samples[oldest_sample].time;
|
||||
if (UNLIKELY(!diff_rtime))
|
||||
diff_rtime = 1;
|
||||
u->hz = hz;
|
||||
|
||||
u->utime = samples[latest_sample].sample.tms_utime;
|
||||
u->stime = samples[latest_sample].sample.tms_stime;
|
||||
u->rtime = samples[latest_sample].time - initial_time;
|
||||
|
||||
total_cputime = diff_utime + diff_stime;
|
||||
total_cputime *= 100; /* pump up by 100 for hundredth */
|
||||
u->usage = total_cputime * 100 / diff_rtime;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int cpucount_linux(void)
|
||||
{
|
||||
return get_nprocs();
|
||||
}
|
||||
|
||||
int cpufrequency_linux(int cpu)
|
||||
{
|
||||
char path[64];
|
||||
char temp[10];
|
||||
int cpu_dev, ret;
|
||||
snprintf(path, sizeof(path), "/sys/devices/system/cpu/cpu%d/cpufreq/cpuinfo_cur_freq", cpu);
|
||||
cpu_dev = open(path, O_RDONLY);
|
||||
if (cpu_dev < 0)
|
||||
return -1;
|
||||
read(cpu_dev, temp, 10);
|
||||
ret = atoi(temp);
|
||||
close(cpu_dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int scalingfrequency_linux(int cpu)
|
||||
{
|
||||
char path[64];
|
||||
char temp[10];
|
||||
int cpu_dev, ret;
|
||||
snprintf(path, sizeof(path), "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_cur_freq", cpu);
|
||||
cpu_dev = open(path, O_RDONLY);
|
||||
if (cpu_dev < 0)
|
||||
return -1;
|
||||
read(cpu_dev, temp, 10);
|
||||
ret = atoi(temp);
|
||||
close(cpu_dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int cpustatetimes_linux(int cpu, struct time_state* data, int max_elements)
|
||||
{
|
||||
int elements_left = max_elements, cpu_dev;
|
||||
char buf[256], path[64], *p;
|
||||
ssize_t read_size;
|
||||
snprintf(path, sizeof(path), "/sys/devices/system/cpu/cpu%d/cpufreq/stats/time_in_state", cpu);
|
||||
cpu_dev = open(path, O_RDONLY);
|
||||
if (cpu_dev < 0)
|
||||
return -1;
|
||||
read_size = read(cpu_dev, buf, sizeof(buf));
|
||||
|
||||
close(cpu_dev);
|
||||
|
||||
p = buf;
|
||||
while(elements_left > 0 && (p-buf) < read_size)
|
||||
{
|
||||
data->frequency = atol(p);
|
||||
/* this loop breaks when it seems the space or line-feed,
|
||||
* so buf points to a number aftwards */
|
||||
while(isdigit(*p++));
|
||||
data->time = atol(p);
|
||||
/* now skip over to the next line */
|
||||
while(isdigit(*p++));
|
||||
data++;
|
||||
elements_left--;
|
||||
}
|
||||
|
||||
return (max_elements - elements_left) ?: -1;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
/***************************************************************************
|
||||
* __________ __ ___.
|
||||
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
||||
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
||||
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
||||
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
||||
* \/ \/ \/ \/ \/
|
||||
* $Id$
|
||||
*
|
||||
* Copyright (C) 2011 Thomas Martitz
|
||||
*
|
||||
* 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
||||
* KIND, either express or implied.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
|
||||
#ifndef __CPUINFO_LINUX_H__
|
||||
#define __CPUINFO_LINUX_H__
|
||||
|
||||
struct cpuusage {
|
||||
long usage; /* in hundredth percent */
|
||||
long utime; /* in clock ticks */
|
||||
long stime; /* in clock ticks */
|
||||
long rtime; /* in clock ticks */
|
||||
long hz; /* how clock ticks per second */
|
||||
};
|
||||
|
||||
struct time_state {
|
||||
long frequency;
|
||||
long time;
|
||||
};
|
||||
|
||||
int cpuusage_linux(struct cpuusage* u);
|
||||
int cpufrequency_linux(int cpu);
|
||||
int scalingfrequency_linux(int cpu);
|
||||
int cpustatetimes_linux(int cpu, struct time_state* data, int max_elements);
|
||||
int cpucount_linux(void);
|
||||
|
||||
#endif /* __CPUINFO_LINUX_H__ */
|
||||
Loading…
Reference in New Issue