/
process.h
149 lines (114 loc) · 2.95 KB
/
process.h
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
/*
* 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"
/*
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;
char desc[256];
public:
char comm[16];
int pid;
int is_idle; /* count this as if the cpu was idle */
int running;
process(const char *_comm, int _pid);
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"; };
};
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 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. */
char next_comm[TASK_COMM_LEN];
int next_pid;
int next_prio;
};
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 {
void *timer;
void *function;
};
struct timer_cancel {
void *timer;
};
struct timer_expire {
void *timer;
unsigned long now;
void *function;
};
struct hrtimer_expire {
void *timer;
int64_t now;
void *function;
};
struct workqueue_start {
void *work;
void *function;
};
struct workqueue_end {
void *work;
};
#endif