WEBVTT

1
00:00.000 --> 00:04.160
So friends, as we know, one of the most important things that we have available

2
00:04.160 --> 00:05.680
to us on our system

3
00:05.680 --> 00:11.390
is the available RAM, i.e. the amount of memory that we can use. Without this,

4
00:11.390 --> 00:12.160
well, our system is

5
00:12.160 --> 00:16.060
going to come to a halt and it's going to begin to perform really, really slugg

6
00:16.060 --> 00:16.880
ishly. We might

7
00:16.880 --> 00:20.860
have to use things such as swapping, which is where we invoke the hard disk to

8
00:20.860 --> 00:22.240
be utilized as virtual

9
00:22.240 --> 00:26.450
memory and the event that memory is running that low. So what we want to do is

10
00:26.450 --> 00:27.120
to utilize

11
00:27.120 --> 00:31.010
Ansible to run some of the more common Linux commands that we can use to
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

11
00:27.120 --> 00:31.010
Ansible to run some of the more common Linux commands that we can use to

12
00:31.010 --> 00:32.320
ultimately diagnose

13
00:32.320 --> 00:36.960
and monitor when the memory happens to be running low and even perhaps

14
00:36.960 --> 00:38.640
identifying the processes

15
00:38.640 --> 00:43.190
which are consuming the most memory. Once we do that, we can run this playbook,

16
00:43.190 --> 00:43.920
target all of the

17
00:43.920 --> 00:48.470
devices in our network and get a quick snapshot of the memory utilization for

18
00:48.470 --> 00:49.520
each device in our

19
00:49.520 --> 00:53.120
managed network. So as we know, there are many different commands that we can

20
00:53.120 --> 00:54.400
use to see our

21
00:54.400 --> 00:58.380
outputs. We can use the free command or we can use things such as the top

22
00:58.380 --> 01:00.080
utility. All of these are
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

22
00:58.380 --> 01:00.080
utility. All of these are

23
01:00.080 --> 01:04.990
valid. In the case here, I'm going to elect to use the free commands. So with

24
01:04.990 --> 01:06.240
that said, let's run

25
01:06.240 --> 01:10.900
that command and see the output that we are getting. So we just say free. And

26
01:10.900 --> 01:12.480
right now we can see

27
01:12.480 --> 01:16.960
we have information relating to the actual memory as well as the swap space.

28
01:16.960 --> 01:17.520
Now, like I say,

29
01:17.520 --> 01:21.990
the swap space is really just talking about the virtual memory. Okay, so this

30
01:21.990 --> 01:22.720
is not really what

31
01:22.720 --> 01:26.800
we're going to target right now. This is only when the hard drive is invoked in

32
01:26.800 --> 01:27.840
the place whereby

33
01:27.840 --> 01:34.090
our memory is running low. So really, we can just effectively grip for the line
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

33
01:27.840 --> 01:34.090
our memory is running low. So really, we can just effectively grip for the line

34
01:34.090 --> 01:35.120
that says memory.

35
01:35.120 --> 01:39.900
Okay, so let's do this right here. If I say free and I grip for the memline,

36
01:39.900 --> 01:40.560
notice the way we are

37
01:40.560 --> 01:44.750
effectively filtering out the bottom right here. And as we can see here, we

38
01:44.750 --> 01:46.000
have the first column,

39
01:46.000 --> 01:50.520
which is just the main itself. Then we have the second column, which denotes

40
01:50.520 --> 01:51.520
the total memory.

41
01:51.520 --> 01:55.040
And then we have the used the free memory that shared the buff cash out as well

42
01:55.040 --> 01:55.920
as the available

43
01:55.920 --> 01:59.320
memory. Now if you so wish, you can see this information and probably a little

44
01:59.320 --> 02:00.080
bit more readable
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

44
01:59.320 --> 02:00.080
bit more readable

45
02:00.080 --> 02:04.490
form if you do free dash H. Also give you the information at a glance. But for

46
02:04.490 --> 02:05.280
our purposes,

47
02:05.280 --> 02:09.330
I'm going to recommend that we just use the free command on its own. This is

48
02:09.330 --> 02:10.080
going to become a

49
02:10.080 --> 02:14.110
parent when we build up the playbook pretty much we're going to be using these

50
02:14.110 --> 02:14.800
raw values

51
02:14.800 --> 02:18.860
to construct a percentage values. We don't want to be mixing and matching

52
02:18.860 --> 02:19.680
potential different

53
02:19.680 --> 02:23.960
values such as gigabytes versus megabytes, that type of thing. Let's just leave

54
02:23.960 --> 02:25.200
it all at the same.

55
02:25.200 --> 02:29.410
So we can see here at a glance, my total memory is 3.5 gig and the available

56
02:29.410 --> 02:30.880
memory is two gig.
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

56
02:29.410 --> 02:30.880
memory is two gig.

57
02:30.880 --> 02:35.300
Therefore, what I want to do is I want to see as a percentage of the total

58
02:35.300 --> 02:35.840
memory,

59
02:35.840 --> 02:40.720
how much of that memory is free. So basically, the last column, we want to be

60
02:40.720 --> 02:41.760
as high as possible.

61
02:41.760 --> 02:45.540
That tells us that we happen to have the most memory available. Now, how we're

62
02:45.540 --> 02:46.240
going to get that

63
02:46.240 --> 02:49.540
in the form of a percentage like I said, we're going to take the raw numbers.

64
02:49.540 --> 02:50.960
So in my case here,

65
02:50.960 --> 02:56.580
what I want to have is 2, 1, 2, 9, 4, 8, 8. And then I want to divide that

66
02:56.580 --> 02:58.160
number by the total

67
02:58.160 --> 03:03.980
memory, which in my case here is going to be 3, 6, 7, 2, 1, 7, 2, which if I
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

67
02:58.160 --> 03:03.980
memory, which in my case here is going to be 3, 6, 7, 2, 1, 7, 2, which if I

68
03:03.980 --> 03:05.600
just calculate right now,

69
03:05.600 --> 03:10.480
it's going to give me a value of round about 0.57. And then all I want to do is

70
03:10.480 --> 03:11.280
I want to times

71
03:11.280 --> 03:14.640
that by 100. And that is going to give me the percentage of available memory.

72
03:14.640 --> 03:15.760
In my case here is

73
03:15.760 --> 03:20.480
50, 7% available. So there are a few things at play here. I want to take the

74
03:20.480 --> 03:21.200
value from

75
03:21.200 --> 03:25.080
this particular column, the seventh column and divide it by the information and

76
03:25.080 --> 03:26.000
the second column

77
03:26.000 --> 03:31.150
and then times that by 100. So if you recall from your skills on learning Linux
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

77
03:26.000 --> 03:31.150
and then times that by 100. So if you recall from your skills on learning Linux

78
03:31.150 --> 03:31.520
via the

79
03:31.520 --> 03:35.520
great hat certified system admin certification, that is the very particular

80
03:35.520 --> 03:36.480
utility that we can

81
03:36.480 --> 03:41.240
use to parse information in this tabular like format. This is going to be the O

82
03:41.240 --> 03:42.400
CH command.

83
03:42.400 --> 03:45.760
So let's see how it actually operates. So let's clear the screen right now.

84
03:45.760 --> 03:46.800
Here is the command

85
03:46.800 --> 03:51.340
just gripping for the main. Now if I take this output here and I pipe it as

86
03:51.340 --> 03:52.400
input into the OCH

87
03:52.400 --> 03:56.690
command, and then I have my single quotation marks and then my double curly

88
03:56.690 --> 03:57.840
braces and inside of the

89
03:57.840 --> 04:02.650
curly braces, I'm going to say prints. And if I say dollar sign one, that acts
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

89
03:57.840 --> 04:02.650
curly braces, I'm going to say prints. And if I say dollar sign one, that acts

90
04:02.650 --> 04:03.760
as a placeholder

91
04:03.760 --> 04:07.280
and tells me to print the very first column. What it's going to see here is

92
04:07.280 --> 04:08.240
just the word

93
04:08.240 --> 04:11.740
meme. This is going to be treated as a column. Okay. So that's the first column

94
04:11.740 --> 04:12.560
. The second,

95
04:12.560 --> 04:17.320
the third, fourth, fifth, sixth and seventh at the end. So if I happen to say I

96
04:17.320 --> 04:18.320
want to see

97
04:18.320 --> 04:21.850
the seventh column, I did dollar seven, now we're getting here at the end

98
04:21.850 --> 04:22.960
column. The actual

99
04:22.960 --> 04:26.300
value here has changed a little bit. That's because there are minor

100
04:26.300 --> 04:27.600
fluctuations in the memory

101
04:27.600 --> 04:31.420
utilization as I'm using my system. Okay. So these values will continually be
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

101
04:27.600 --> 04:31.420
utilization as I'm using my system. Okay. So these values will continually be

102
04:31.420 --> 04:32.080
in flux and

103
04:32.080 --> 04:35.630
changing ever so slightly unless something major happens, in which case they'll

104
04:35.630 --> 04:36.560
change greatly.

105
04:36.560 --> 04:40.930
So this is the seventh column. And if I want to get the total, I would use the

106
04:40.930 --> 04:41.440
second column,

107
04:41.440 --> 04:46.800
which is going to show me 3672172. Now here's the cool thing. I can actually

108
04:46.800 --> 04:48.320
run the calculation

109
04:48.320 --> 04:54.110
right here directly. I can just say print dollar sign seven divided by dollar

110
04:54.110 --> 04:55.360
sign two. Pretty much

111
04:55.360 --> 04:58.450
take the information we see from the seventh column and divide it by the

112
04:58.450 --> 04:59.440
information we see

113
04:59.440 --> 05:03.670
in the second column and print the output. So let's try this right here and
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

113
04:59.440 --> 05:03.670
in the second column and print the output. So let's try this right here and

114
05:03.670 --> 05:04.080
look at this.

115
05:04.080 --> 05:08.160
We're actually getting 0.58. We have a slight fluctuation. I believe my

116
05:08.160 --> 05:09.600
previous calculation was

117
05:09.600 --> 05:13.330
59 or 57 around about that. Anyway, this is what we're seeing now. We're

118
05:13.330 --> 05:14.560
actually getting a little

119
05:14.560 --> 05:18.800
bit too specific information in the case here. We're getting more than two

120
05:18.800 --> 05:20.000
decimal points. Now

121
05:20.000 --> 05:23.960
what I can do is I can specify to all that I want to have a float value,

122
05:23.960 --> 05:24.720
including a very

123
05:24.720 --> 05:28.070
particular amount of decimal points. So does very briefly, we have a difference

124
05:28.070 --> 05:28.560
between an

125
05:28.560 --> 05:32.050
integer, which is just a regular whole number such as the number four, or
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

125
05:28.560 --> 05:32.050
integer, which is just a regular whole number such as the number four, or

126
05:32.050 --> 05:33.600
perhaps maybe the number nine,

127
05:33.600 --> 05:37.310
a floating point value would be including that decimal notation. So I could say

128
05:37.310 --> 05:38.000
, for example,

129
05:38.000 --> 05:41.970
nine point one two, this would be a floating point. And again, we'd be using

130
05:41.970 --> 05:43.440
here two decimal points.

131
05:43.440 --> 05:47.490
So like I say, as opposed to getting this value here, so if I change the print

132
05:47.490 --> 05:48.320
statement to be

133
05:48.320 --> 05:53.070
print F and then within quotation marks, I specify the amount of decimal points

134
05:53.070 --> 05:53.680
I want to include,

135
05:53.680 --> 05:59.440
I can say percentage to F. And now what I will do is I will have my comma here,

136
05:59.440 --> 05:59.600
and then

137
05:59.600 --> 06:03.280
be around the calculation. So if I hit enter now, we're actually just getting
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

137
05:59.600 --> 06:03.280
be around the calculation. So if I hit enter now, we're actually just getting

138
06:03.280 --> 06:04.960
back 0.58. In fact,

139
06:04.960 --> 06:08.520
let me add a new line here. So it looks a little bit neater. So I'll say backsl

140
06:08.520 --> 06:10.000
ash in and I answer,

141
06:10.000 --> 06:12.830
this looks a little bit nicer. Now, like I say, if you want to convert this

142
06:12.830 --> 06:13.840
into a full percentage,

143
06:13.840 --> 06:18.490
we're going to have to modify the commands so as to times it by the value 100.

144
06:18.490 --> 06:19.120
So let's try this

145
06:19.120 --> 06:24.150
right here. Okay. And again, we're getting back the information 57.78%. And

146
06:24.150 --> 06:24.480
again, if we just

147
06:24.480 --> 06:28.600
wanted to see one decimal point, I could change that to one F right here. And

148
06:28.600 --> 06:29.680
to enter, now we're

149
06:29.680 --> 06:33.770
getting 57.9%. Okay. So whatever you want to see, if you want to see more
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

149
06:29.680 --> 06:33.770
getting 57.9%. Okay. So whatever you want to see, if you want to see more

150
06:33.770 --> 06:34.480
information,

151
06:34.480 --> 06:38.210
more specific, you could say we want four floats, that will give us even more

152
06:38.210 --> 06:39.600
specificity. So in my

153
06:39.600 --> 06:42.960
case here, let's maybe go with dot one. Okay. So what we want to do is you want

154
06:42.960 --> 06:43.920
to basically apply

155
06:43.920 --> 06:49.000
this information and run it within our Ansible Playbook. So if I just created a

156
06:49.000 --> 06:49.760
playbook called

157
06:49.760 --> 06:53.880
play one dot YML, that's going to insert mode, have our free hyphens at the top

158
06:53.880 --> 06:54.960
, give this playbook

159
06:54.960 --> 06:58.670
in name, and I'll just say play one testing memory. Now, how am I going to

160
06:58.670 --> 06:59.920
target? Let's target the

161
06:59.920 --> 07:02.850
all groups so that will be all devices in my network. And right now, say the
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

161
06:59.920 --> 07:02.850
all groups so that will be all devices in my network. And right now, say the

162
07:02.850 --> 07:03.680
gather facts to be the

163
07:03.680 --> 07:08.860
billion value of false. Now I define my tasks. Now the task here is simply

164
07:08.860 --> 07:10.080
going to be use the

165
07:10.080 --> 07:14.580
free commands and parse memory percentage. So what am I going to do here? I'm

166
07:14.580 --> 07:16.240
going to say Ansible.

167
07:16.240 --> 07:20.050
I'm going to use the built in shell module. And all I want to do is if I just

168
07:20.050 --> 07:20.560
go back,

169
07:20.560 --> 07:25.100
and I just copy this particular command right here. And all I will do is I'll

170
07:25.100 --> 07:25.840
paste it directly

171
07:25.840 --> 07:29.400
into the playbook. Now what I want to do is I want to register this output and

172
07:29.400 --> 07:30.080
let's just give it
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

172
07:29.400 --> 07:30.080
let's just give it

173
07:30.080 --> 07:33.750
the variable name memory percent. So right now all I will do at the moment is I

174
07:33.750 --> 07:34.800
'll just print out

175
07:34.800 --> 07:39.160
the memories. I'll just say print the output. And now I will use the Ansible

176
07:39.160 --> 07:40.800
built in debug module.

177
07:40.800 --> 07:44.160
And then I'll specify the message and I'll just say inventory host name to get

178
07:44.160 --> 07:45.040
the host name of

179
07:45.040 --> 07:49.630
the device. And I'll just say has and I'll grab the memory percent variable I

180
07:49.630 --> 07:50.880
've just captured,

181
07:50.880 --> 07:54.350
and I'll add a little percent design afterwards, and then just say the word

182
07:54.350 --> 07:55.360
free. So let's actually

183
07:55.360 --> 07:59.310
see how this shakes out them. So if I just say Ansible playbook, play one dot y

184
07:59.310 --> 08:00.560
ml and to enter,
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

184
07:59.310 --> 08:00.560
ml and to enter,

185
08:00.560 --> 08:03.320
open in fact what I want to do here is that I just want to print out the

186
08:03.320 --> 08:04.240
standard out. So

187
08:04.240 --> 08:07.890
let's just go back to the variable here and I'll just grab STD out, run this

188
08:07.890 --> 08:08.800
again. Look at this

189
08:08.800 --> 08:15.440
right here. We can see the blue box has 60.9% free and the yellow box has 60.6%

190
08:15.440 --> 08:16.480
free. And again,

191
08:16.480 --> 08:19.740
if I wanted to make that a little bit more descriptive, I could change it to

192
08:19.740 --> 08:20.480
say memory

193
08:20.480 --> 08:23.640
phrase. It's a little bit clearer. So for Iran, it's there we get the values

194
08:23.640 --> 08:25.200
here. Now suppose we also

195
08:25.200 --> 08:29.910
want to see the processes which are consuming the most memory. Well, if I do ps

196
08:29.910 --> 08:30.640
dash e, this is
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

196
08:29.910 --> 08:30.640
dash e, this is

197
08:30.640 --> 08:34.420
going to show me absolutely all my processes scroll on up to the very top, we

198
08:34.420 --> 08:34.960
could see

199
08:34.960 --> 08:38.690
absolutely everything. Now right now, this is displaying the information and a

200
08:38.690 --> 08:39.680
numerical value

201
08:39.680 --> 08:43.800
with the process ID increasing gradually we have process ID one all the way

202
08:43.800 --> 08:44.960
down. So if I want to

203
08:44.960 --> 08:48.790
modify the format, I can also use the dash o fly. Okay, so now what I want to

204
08:48.790 --> 08:49.520
do is I want to

205
08:49.520 --> 08:53.390
specify which information do I want to see here. So I can say I want to see the

206
08:53.390 --> 08:54.560
process ID, which

207
08:54.560 --> 08:58.700
shows me just the process IDs. If I also want to see the parent process ID, I

208
08:58.700 --> 08:59.680
can add a comma and

209
08:59.680 --> 09:03.200
just say PP ID, which shows me both of them. If I then want to see the
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

209
08:59.680 --> 09:03.200
just say PP ID, which shows me both of them. If I then want to see the

210
09:03.200 --> 09:04.880
associated command, I can say

211
09:04.880 --> 09:09.970
comma CMD, which shows me the command which is associated. And then I can say

212
09:09.970 --> 09:11.360
comma percentage

213
09:11.360 --> 09:15.380
of memory being used. So now we get this type of information. Now right now,

214
09:15.380 --> 09:16.400
this is still sorting

215
09:16.400 --> 09:20.860
things and numerical value, increasing via the process ID, what we want to see

216
09:20.860 --> 09:21.200
here,

217
09:21.200 --> 09:26.290
is we want to sort things via memory utilization. So if I say dash dash sort is

218
09:26.290 --> 09:27.440
equal to, and then I

219
09:27.440 --> 09:32.480
say percentage of memory, what it's going to do here, it's going to show me the
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

219
09:27.440 --> 09:32.480
say percentage of memory, what it's going to do here, it's going to show me the

220
09:32.480 --> 09:33.680
usage of memory

221
09:33.680 --> 09:37.040
and gradually increasing order. So right now the process is using the most

222
09:37.040 --> 09:38.880
memory at the very bottom

223
09:38.880 --> 09:42.260
and as you move on up, they use less and less memory. If you want to invert

224
09:42.260 --> 09:43.840
that logic, we can say

225
09:43.840 --> 09:47.940
sort minus percentage M, which is going to flip it. So now we get the ones that

226
09:47.940 --> 09:48.800
use the least at the

227
09:48.800 --> 09:52.130
bottom and at the very top, we see the processes using the most memory, which

228
09:52.130 --> 09:53.040
in my case here is

229
09:53.040 --> 09:56.660
the nome shell. Now we don't want to see absolutely everything. So what I could

230
09:56.660 --> 09:57.680
do once again is to

231
09:57.680 --> 10:00.700
use the head command. So I can pipe that into the head command, which is going
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

231
09:57.680 --> 10:00.700
use the head command. So I can pipe that into the head command, which is going

232
10:00.700 --> 10:01.840
to show me the top

233
10:01.840 --> 10:06.270
10. And in my case here, let me just say I wanted to see the top five. So I can

234
10:06.270 --> 10:07.440
say his head dash

235
10:07.440 --> 10:11.200
n for number of lines and then say six, which is going to show me my column

236
10:11.200 --> 10:12.480
here, which acts as

237
10:12.480 --> 10:16.640
one value. And then the next five values are going to be the five processes

238
10:16.640 --> 10:17.760
considering the most

239
10:17.760 --> 10:21.540
memory. So let's take this custom command here, and we can add it into our

240
10:21.540 --> 10:22.640
playbook. So let's give

241
10:22.640 --> 10:28.050
this a name and I'll just say show the top five most memory intensive processes

242
10:28.050 --> 10:29.120
. Again, I'll use

243
10:29.120 --> 10:32.950
the Antibel built in shell module and just type in this custom command that we
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

243
10:29.120 --> 10:32.950
the Antibel built in shell module and just type in this custom command that we

244
10:32.950 --> 10:33.760
've crafted. And

245
10:33.760 --> 10:37.410
then I can capture the output via the register keyword and I'll register the

246
10:37.410 --> 10:38.640
output of this command

247
10:38.640 --> 10:43.390
as the variable. Let's just say this as top memory processes. Then I can add a

248
10:43.390 --> 10:44.560
new task and just say

249
10:44.560 --> 10:49.630
prints the top processes. And again, we use the Antibel built in debug module.

250
10:49.630 --> 10:50.480
And let's print

251
10:50.480 --> 10:54.480
the message to my message will have my two quotation marks and my double curly

252
10:54.480 --> 10:55.200
braces. And all I'm

253
10:55.200 --> 10:58.980
going to specify is that I want to print out the top memory processes variable

254
10:58.980 --> 11:00.080
I've just created
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

254
10:58.980 --> 11:00.080
I've just created

255
11:00.080 --> 11:03.870
and I want to grab the STD out. So let's save this right here. And we'll just

256
11:03.870 --> 11:04.160
say,

257
11:04.160 --> 11:08.250
answer my playbook, play one dot yml and to enter. And as we can see here, we

258
11:08.250 --> 11:09.440
get the output of each

259
11:09.440 --> 11:12.790
device. We can see the amount of memory free. And then we run this particular

260
11:12.790 --> 11:13.520
command. Now,

261
11:13.520 --> 11:18.220
as it stands, the output here is super super ugly. So what I can do is as

262
11:18.220 --> 11:19.200
opposed to printing

263
11:19.200 --> 11:23.840
STD out, let me print STD out lines, okay, which is going to help us with these

264
11:23.840 --> 11:24.720
new line characters.

265
11:24.720 --> 11:28.700
Let's try this again, rerun the playbook. And that this looks a lot better. So

266
11:28.700 --> 11:29.280
at a glance,

267
11:29.280 --> 11:33.490
we can quickly see how much memory is free, as well as printing the top
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

267
11:29.280 --> 11:33.490
we can quickly see how much memory is free, as well as printing the top

268
11:33.490 --> 11:34.800
processes on each

269
11:34.800 --> 11:38.860
device here is the information here for the blue box. And below here is the

270
11:38.860 --> 11:40.160
information for the

271
11:40.160 --> 11:41.040
yellow box.