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
|
/*
* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/HashMap.h>
#include <AK/NonnullOwnPtrVector.h>
#include <AK/String.h>
#include <AK/Vector.h>
#include <LibGUI/Model.h>
#include <unistd.h>
class GraphWidget;
class ProcessModel final : public GUI::Model {
public:
enum Column {
Icon = 0,
PID,
Name,
CPU,
State,
User,
Virtual,
DirtyPrivate,
Pledge,
Physical,
CleanInode,
PurgeableVolatile,
PurgeableNonvolatile,
Veil,
Processor,
Priority,
TID,
PPID,
PGID,
SID,
Syscalls,
InodeFaults,
ZeroFaults,
CowFaults,
FileReadBytes,
FileWriteBytes,
UnixSocketReadBytes,
UnixSocketWriteBytes,
IPv4SocketReadBytes,
IPv4SocketWriteBytes,
__Count
};
static ProcessModel& the();
static NonnullRefPtr<ProcessModel> create() { return adopt_ref(*new ProcessModel); }
virtual ~ProcessModel() override;
virtual int row_count(const GUI::ModelIndex&) const override;
virtual int column_count(const GUI::ModelIndex&) const override;
virtual String column_name(int column) const override;
virtual GUI::Variant data(const GUI::ModelIndex&, GUI::ModelRole) const override;
virtual void update() override;
virtual bool is_column_sortable(int column_index) const override { return column_index != Column::Icon; }
struct CpuInfo {
u32 id;
float total_cpu_percent { 0.0 };
float total_cpu_percent_kernel { 0.0 };
explicit CpuInfo(u32 id)
: id(id)
{
}
};
Function<void(const NonnullOwnPtrVector<CpuInfo>&)> on_cpu_info_change;
Function<void(int process_count, int thread_count)> on_state_update;
const NonnullOwnPtrVector<CpuInfo>& cpus() const { return m_cpus; }
private:
ProcessModel();
struct ThreadState {
pid_t tid;
pid_t pid;
pid_t ppid;
pid_t pgid;
pid_t sid;
unsigned ticks_user;
unsigned ticks_kernel;
bool kernel;
String executable;
String name;
String state;
String user;
String pledge;
String veil;
u32 cpu;
u32 priority;
size_t amount_virtual;
size_t amount_resident;
size_t amount_dirty_private;
size_t amount_clean_inode;
size_t amount_purgeable_volatile;
size_t amount_purgeable_nonvolatile;
unsigned syscall_count;
unsigned inode_faults;
unsigned zero_faults;
unsigned cow_faults;
unsigned unix_socket_read_bytes;
unsigned unix_socket_write_bytes;
unsigned ipv4_socket_read_bytes;
unsigned ipv4_socket_write_bytes;
unsigned file_read_bytes;
unsigned file_write_bytes;
float cpu_percent;
float cpu_percent_kernel;
};
struct Thread {
ThreadState current_state;
ThreadState previous_state;
};
HashMap<int, NonnullOwnPtr<Thread>> m_threads;
NonnullOwnPtrVector<CpuInfo> m_cpus;
Vector<int> m_tids;
RefPtr<Core::File> m_proc_all;
GUI::Icon m_kernel_process_icon;
};
|
