1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
/*
* Copyright 2010, Intel Corporation
*
* This file is part of PowerTOP
*
* This program file 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; version 2 of the License.
*
* 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 in a file named COPYING; if not, write to the
* Free Software Foundation, Inc,
* 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA
* or just google for it.
*
* Authors:
* Arjan van de Ven <arjan@linux.intel.com>
*/
#ifndef _INCLUDE_GUARD_PROCESS_H
#define _INCLUDE_GUARD_PROCESS_H
#include <stdint.h>
#include "powerconsumer.h"
#ifdef __x86_64__
#define BIT64 1
#endif
/*
Need to collect
* CPU time consumed by each application
* Number of wakeups out of idle -- received and wakeups sent
* Number of disk dirties (inode for now)
*/
class process : public power_consumer {
uint64_t running_since;
public:
char desc[256];
int tgid;
char comm[16];
int pid;
int is_idle; /* count this as if the cpu was idle */
int running;
int is_kernel; /* kernel thread */
process(const char *_comm, int _pid, int _tid = 0);
virtual void schedule_thread(uint64_t time, int thread_id);
virtual uint64_t deschedule_thread(uint64_t time, int thread_id = 0);
virtual void account_disk_dirty(void);
virtual const char * description(void);
virtual const char * name(void) { return "process"; };
virtual const char * type(void) { return "Process"; };
virtual double usage_summary(void);
virtual const char * usage_units_summary(void);
};
extern vector <class process *> all_processes;
extern double measurement_time;
extern void start_process_measurement(void);
extern void end_process_measurement(void);
extern void process_process_data(void);
extern void end_process_data(void);
extern void merge_processes(void);
extern class process * find_create_process(char *comm, int pid);
extern void all_processes_to_all_power(void);
extern void process_update_display(void);
extern void html_process_update_display(void);
extern void html_summary(void);
extern void clear_timers(void);
#define TASK_COMM_LEN 16
struct sched_switch {
char prev_comm[TASK_COMM_LEN];
int prev_pid;
int prev_prio;
long prev_state; /* Arjan weeps. */
#ifdef BIT64
int dummy;
#endif
char next_comm[TASK_COMM_LEN];
int next_pid;
int next_prio;
} __attribute__((packed));
struct irq_entry {
int irq;
int len;
char handler[16];
};
struct wakeup_entry {
char comm[TASK_COMM_LEN];
int pid;
int prio;
int success;
};
struct irq_exit {
int irq;
int ret;
};
struct softirq_entry {
uint32_t vec;
};
struct timer_start {
#ifdef BIT64
int padding;
#endif
void *timer;
void *function;
} __attribute__((packed));;
struct timer_cancel {
#ifdef BIT64
int padding;
#endif
void *timer;
} __attribute__((packed));;
struct timer_expire {
#ifdef BIT64
int padding;
#endif
void *timer;
unsigned long now;
void *function;
} __attribute__((packed));;
struct hrtimer_expire {
#ifdef BIT64
int padding;
#endif
void *timer;
int64_t now;
void *function;
} __attribute__((packed));;
struct workqueue_start {
#ifdef BIT64
int padding;
#endif
void *work;
void *function;
} __attribute__((packed));;
struct workqueue_end {
#ifdef BIT64
int padding;
#endif
void *work;
} __attribute__((packed));
struct dirty_inode {
uint32_t dev;
};
#endif
|
