ResServerFundamentals.java
24.7 KB
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
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
/*
* Decompiled with CFR 0_118.
*/
package com.scene7.is.ipp.messages;
import com.scene7.is.ipp.messages.InMessage;
import com.scene7.is.ipp.messages.Ipp;
import com.scene7.is.ipp.messages.IppBool;
import com.scene7.is.ipp.messages.IppDate;
import com.scene7.is.ipp.messages.IppInt;
import com.scene7.is.ipp.messages.IppInt64;
import com.scene7.is.ipp.messages.IppString;
import com.scene7.is.ipp.messages.Offset;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
public class ResServerFundamentals
extends InMessage {
static int MessageNumber = 2097920;
private String serverName_;
private String serverEdition_;
private int buildNumber_;
private int ippLowVersionMinor_;
private int ippLowVersionMajor_;
private int ippHighVersionMinor_;
private int ippHighVersionMajor_;
private String serverOsName_;
private boolean is64Bit_;
private boolean imageRenderingAvailable_;
private int imageRenderingSchema_;
private long uptime_;
private long serverBuildDate_;
private int numClients_;
private int clientOverlap_;
private long imagesServed_;
private long pixelsServed_;
private long imageBytesServed_;
private long totalBytesServed_;
private long userTime_;
private long systemTime_;
private long processId_;
private long mallocArenaBytes_;
private long mallocOrdBlocks_;
private long mallocMmapBlocks_;
private long mallocMmapBytes_;
private long mallocActiveBytes_;
private long mallocFreeBytes_;
private long mallocKeepCostBytes_;
private long heapTotalBytes_;
private long processResidentBytes_;
private int numSynchronousReads_;
private int synchronousReadMillisec_;
private int numSynchronousReadBytes_;
private int numSynchronousWrites_;
private int synchronousWriteMillisec_;
private int numSynchronousWriteBytes_;
private int numAsynchronousReads_;
private int asynchronousReadMillisec_;
private int numAsynchronousReadBytes_;
private int numAsynchronousWrites_;
private int asynchronousWriteMillisec_;
private int numAsynchronousWriteBytes_;
public ResServerFundamentals(int tag, String serverName, String serverEdition, int buildNumber, int ippLowVersionMinor, int ippLowVersionMajor, int ippHighVersionMinor, int ippHighVersionMajor, String serverOsName, boolean is64Bit, boolean imageRenderingAvailable, int imageRenderingSchema, long uptime, long serverBuildDate, int numClients, int clientOverlap, long imagesServed, long pixelsServed, long imageBytesServed, long totalBytesServed, long userTime, long systemTime, long processId, long mallocArenaBytes, long mallocOrdBlocks, long mallocMmapBlocks, long mallocMmapBytes, long mallocActiveBytes, long mallocFreeBytes, long mallocKeepCostBytes, long heapTotalBytes, long processResidentBytes, int numSynchronousReads, int synchronousReadMillisec, int numSynchronousReadBytes, int numSynchronousWrites, int synchronousWriteMillisec, int numSynchronousWriteBytes, int numAsynchronousReads, int asynchronousReadMillisec, int numAsynchronousReadBytes, int numAsynchronousWrites, int asynchronousWriteMillisec, int numAsynchronousWriteBytes, int headClientId) {
this.tag_ = tag;
this.headerClientId_ = headClientId;
this.serverName_ = serverName;
this.serverEdition_ = serverEdition;
this.buildNumber_ = buildNumber;
this.ippLowVersionMinor_ = ippLowVersionMinor;
this.ippLowVersionMajor_ = ippLowVersionMajor;
this.ippHighVersionMinor_ = ippHighVersionMinor;
this.ippHighVersionMajor_ = ippHighVersionMajor;
this.serverOsName_ = serverOsName;
this.is64Bit_ = is64Bit;
this.imageRenderingAvailable_ = imageRenderingAvailable;
this.imageRenderingSchema_ = imageRenderingSchema;
this.uptime_ = uptime;
this.serverBuildDate_ = serverBuildDate;
this.numClients_ = numClients;
this.clientOverlap_ = clientOverlap;
this.imagesServed_ = imagesServed;
this.pixelsServed_ = pixelsServed;
this.imageBytesServed_ = imageBytesServed;
this.totalBytesServed_ = totalBytesServed;
this.userTime_ = userTime;
this.systemTime_ = systemTime;
this.processId_ = processId;
this.mallocArenaBytes_ = mallocArenaBytes;
this.mallocOrdBlocks_ = mallocOrdBlocks;
this.mallocMmapBlocks_ = mallocMmapBlocks;
this.mallocMmapBytes_ = mallocMmapBytes;
this.mallocActiveBytes_ = mallocActiveBytes;
this.mallocFreeBytes_ = mallocFreeBytes;
this.mallocKeepCostBytes_ = mallocKeepCostBytes;
this.heapTotalBytes_ = heapTotalBytes;
this.processResidentBytes_ = processResidentBytes;
this.numSynchronousReads_ = numSynchronousReads;
this.synchronousReadMillisec_ = synchronousReadMillisec;
this.numSynchronousReadBytes_ = numSynchronousReadBytes;
this.numSynchronousWrites_ = numSynchronousWrites;
this.synchronousWriteMillisec_ = synchronousWriteMillisec;
this.numSynchronousWriteBytes_ = numSynchronousWriteBytes;
this.numAsynchronousReads_ = numAsynchronousReads;
this.asynchronousReadMillisec_ = asynchronousReadMillisec;
this.numAsynchronousReadBytes_ = numAsynchronousReadBytes;
this.numAsynchronousWrites_ = numAsynchronousWrites;
this.asynchronousWriteMillisec_ = asynchronousWriteMillisec;
this.numAsynchronousWriteBytes_ = numAsynchronousWriteBytes;
int fixedLength = 248;
Offset varPos = new Offset(fixedLength);
try {
varPos.val += serverName.getBytes("UTF-8").length + 1;
}
catch (UnsupportedEncodingException e) {
throw new AssertionError(e);
}
try {
varPos.val += serverEdition.getBytes("UTF-8").length + 1;
}
catch (UnsupportedEncodingException e) {
throw new AssertionError(e);
}
try {
varPos.val += serverOsName.getBytes("UTF-8").length + 1;
}
catch (UnsupportedEncodingException e) {
throw new AssertionError(e);
}
this.messageLength_ = varPos.val;
varPos.val = fixedLength;
Offset pos = new Offset(0);
this.headBuffer_ = new byte[32];
this.bodyBuffer_ = new byte[this.messageLength_];
Ipp.StuffHeader(this.headBuffer_, this.headerClientId_, tag, MessageNumber, this.messageLength_);
IppString.Stuff(this.bodyBuffer_, pos, varPos, this.serverName_);
IppString.Stuff(this.bodyBuffer_, pos, varPos, this.serverEdition_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.buildNumber_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.ippLowVersionMinor_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.ippLowVersionMajor_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.ippHighVersionMinor_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.ippHighVersionMajor_);
IppString.Stuff(this.bodyBuffer_, pos, varPos, this.serverOsName_);
IppBool.Stuff(this.bodyBuffer_, pos, null, this.is64Bit_);
IppBool.Stuff(this.bodyBuffer_, pos, null, this.imageRenderingAvailable_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.imageRenderingSchema_);
Ipp.StuffNullBytes(this.bodyBuffer_, pos, 4);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.uptime_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.serverBuildDate_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.numClients_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.clientOverlap_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.imagesServed_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.pixelsServed_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.imageBytesServed_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.totalBytesServed_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.userTime_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.systemTime_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.processId_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.mallocArenaBytes_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.mallocOrdBlocks_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.mallocMmapBlocks_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.mallocMmapBytes_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.mallocActiveBytes_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.mallocFreeBytes_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.mallocKeepCostBytes_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.heapTotalBytes_);
IppInt64.Stuff(this.bodyBuffer_, pos, null, this.processResidentBytes_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.numSynchronousReads_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.synchronousReadMillisec_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.numSynchronousReadBytes_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.numSynchronousWrites_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.synchronousWriteMillisec_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.numSynchronousWriteBytes_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.numAsynchronousReads_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.asynchronousReadMillisec_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.numAsynchronousReadBytes_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.numAsynchronousWrites_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.asynchronousWriteMillisec_);
IppInt.Stuff(this.bodyBuffer_, pos, null, this.numAsynchronousWriteBytes_);
Ipp.Assert(pos.val == fixedLength, "IppWatermarkType length");
}
public ResServerFundamentals() {
}
public void process(int headClientId, int tg, byte[] bf) {
this.headerClientId_ = headClientId;
this.tag_ = tg;
this.messageLength_ = bf.length;
this.headBuffer_ = new byte[32];
Ipp.StuffHeader(this.headBuffer_, this.headerClientId_, this.tag_, MessageNumber, this.messageLength_);
this.bodyBuffer_ = bf;
Offset pos = new Offset(0);
this.serverName_ = IppString.Unstuff(this.bodyBuffer_, pos);
this.serverEdition_ = IppString.Unstuff(this.bodyBuffer_, pos);
this.buildNumber_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.ippLowVersionMinor_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.ippLowVersionMajor_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.ippHighVersionMinor_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.ippHighVersionMajor_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.serverOsName_ = IppString.Unstuff(this.bodyBuffer_, pos);
this.is64Bit_ = IppBool.Unstuff(this.bodyBuffer_, pos);
this.imageRenderingAvailable_ = IppBool.Unstuff(this.bodyBuffer_, pos);
this.imageRenderingSchema_ = IppInt.Unstuff(this.bodyBuffer_, pos);
pos.val += 4;
this.uptime_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.serverBuildDate_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.numClients_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.clientOverlap_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.imagesServed_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.pixelsServed_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.imageBytesServed_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.totalBytesServed_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.userTime_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.systemTime_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.processId_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.mallocArenaBytes_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.mallocOrdBlocks_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.mallocMmapBlocks_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.mallocMmapBytes_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.mallocActiveBytes_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.mallocFreeBytes_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.mallocKeepCostBytes_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.heapTotalBytes_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.processResidentBytes_ = IppInt64.Unstuff(this.bodyBuffer_, pos);
this.numSynchronousReads_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.synchronousReadMillisec_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.numSynchronousReadBytes_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.numSynchronousWrites_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.synchronousWriteMillisec_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.numSynchronousWriteBytes_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.numAsynchronousReads_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.asynchronousReadMillisec_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.numAsynchronousReadBytes_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.numAsynchronousWrites_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.asynchronousWriteMillisec_ = IppInt.Unstuff(this.bodyBuffer_, pos);
this.numAsynchronousWriteBytes_ = IppInt.Unstuff(this.bodyBuffer_, pos);
}
public int classification() {
return 1;
}
public int id() {
return MessageNumber;
}
public void print(Writer tf, String heading) throws IOException {
tf.write("\n");
tf.write(heading);
tf.write(": ResServerFundamentals ");
Ipp.PrintHex(tf, MessageNumber);
tf.write("\n");
tf.write("headClientId: " + this.headerClientId() + "\n");
Ipp.PrintTag(tf, "tag: ", this.tag());
tf.write("length: " + this.length());
tf.write("\n");
IppString.Print(tf, "serverName: ", this.serverName_);
IppString.Print(tf, "serverEdition: ", this.serverEdition_);
IppInt.Print(tf, "buildNumber: ", this.buildNumber_);
IppInt.Print(tf, "ippLowVersionMinor: ", this.ippLowVersionMinor_);
IppInt.Print(tf, "ippLowVersionMajor: ", this.ippLowVersionMajor_);
IppInt.Print(tf, "ippHighVersionMinor: ", this.ippHighVersionMinor_);
IppInt.Print(tf, "ippHighVersionMajor: ", this.ippHighVersionMajor_);
IppString.Print(tf, "serverOsName: ", this.serverOsName_);
IppBool.Print(tf, "is64Bit: ", this.is64Bit_);
IppBool.Print(tf, "imageRenderingAvailable: ", this.imageRenderingAvailable_);
IppInt.Print(tf, "imageRenderingSchema: ", this.imageRenderingSchema_);
IppInt64.Print(tf, "uptime: ", this.uptime_);
IppDate.Print(tf, "serverBuildDate: ", this.serverBuildDate_);
IppInt.Print(tf, "numClients: ", this.numClients_);
IppInt.Print(tf, "clientOverlap: ", this.clientOverlap_);
IppInt64.Print(tf, "imagesServed: ", this.imagesServed_);
IppInt64.Print(tf, "pixelsServed: ", this.pixelsServed_);
IppInt64.Print(tf, "imageBytesServed: ", this.imageBytesServed_);
IppInt64.Print(tf, "totalBytesServed: ", this.totalBytesServed_);
IppInt64.Print(tf, "userTime: ", this.userTime_);
IppInt64.Print(tf, "systemTime: ", this.systemTime_);
IppInt64.Print(tf, "processId: ", this.processId_);
IppInt64.Print(tf, "mallocArenaBytes: ", this.mallocArenaBytes_);
IppInt64.Print(tf, "mallocOrdBlocks: ", this.mallocOrdBlocks_);
IppInt64.Print(tf, "mallocMmapBlocks: ", this.mallocMmapBlocks_);
IppInt64.Print(tf, "mallocMmapBytes: ", this.mallocMmapBytes_);
IppInt64.Print(tf, "mallocActiveBytes: ", this.mallocActiveBytes_);
IppInt64.Print(tf, "mallocFreeBytes: ", this.mallocFreeBytes_);
IppInt64.Print(tf, "mallocKeepCostBytes: ", this.mallocKeepCostBytes_);
IppInt64.Print(tf, "heapTotalBytes: ", this.heapTotalBytes_);
IppInt64.Print(tf, "processResidentBytes: ", this.processResidentBytes_);
IppInt.Print(tf, "numSynchronousReads: ", this.numSynchronousReads_);
IppInt.Print(tf, "synchronousReadMillisec: ", this.synchronousReadMillisec_);
IppInt.Print(tf, "numSynchronousReadBytes: ", this.numSynchronousReadBytes_);
IppInt.Print(tf, "numSynchronousWrites: ", this.numSynchronousWrites_);
IppInt.Print(tf, "synchronousWriteMillisec: ", this.synchronousWriteMillisec_);
IppInt.Print(tf, "numSynchronousWriteBytes: ", this.numSynchronousWriteBytes_);
IppInt.Print(tf, "numAsynchronousReads: ", this.numAsynchronousReads_);
IppInt.Print(tf, "asynchronousReadMillisec: ", this.asynchronousReadMillisec_);
IppInt.Print(tf, "numAsynchronousReadBytes: ", this.numAsynchronousReadBytes_);
IppInt.Print(tf, "numAsynchronousWrites: ", this.numAsynchronousWrites_);
IppInt.Print(tf, "asynchronousWriteMillisec: ", this.asynchronousWriteMillisec_);
IppInt.Print(tf, "numAsynchronousWriteBytes: ", this.numAsynchronousWriteBytes_);
}
public String toString() {
StringBuffer buffer = new StringBuffer();
buffer.append("ResServerFundamentals ");
buffer.append("[serverName: " + String.valueOf(this.serverName_) + "],");
buffer.append("[serverEdition: " + String.valueOf(this.serverEdition_) + "],");
buffer.append("[buildNumber: " + String.valueOf(this.buildNumber_) + "],");
buffer.append("[ippLowVersionMinor: " + String.valueOf(this.ippLowVersionMinor_) + "],");
buffer.append("[ippLowVersionMajor: " + String.valueOf(this.ippLowVersionMajor_) + "],");
buffer.append("[ippHighVersionMinor: " + String.valueOf(this.ippHighVersionMinor_) + "],");
buffer.append("[ippHighVersionMajor: " + String.valueOf(this.ippHighVersionMajor_) + "],");
buffer.append("[serverOsName: " + String.valueOf(this.serverOsName_) + "],");
buffer.append("[is64Bit: " + String.valueOf(this.is64Bit_) + "],");
buffer.append("[imageRenderingAvailable: " + String.valueOf(this.imageRenderingAvailable_) + "],");
buffer.append("[imageRenderingSchema: " + String.valueOf(this.imageRenderingSchema_) + "],");
buffer.append("[uptime: " + String.valueOf(this.uptime_) + "],");
buffer.append("[serverBuildDate: " + String.valueOf(this.serverBuildDate_) + "],");
buffer.append("[numClients: " + String.valueOf(this.numClients_) + "],");
buffer.append("[clientOverlap: " + String.valueOf(this.clientOverlap_) + "],");
buffer.append("[imagesServed: " + String.valueOf(this.imagesServed_) + "],");
buffer.append("[pixelsServed: " + String.valueOf(this.pixelsServed_) + "],");
buffer.append("[imageBytesServed: " + String.valueOf(this.imageBytesServed_) + "],");
buffer.append("[totalBytesServed: " + String.valueOf(this.totalBytesServed_) + "],");
buffer.append("[userTime: " + String.valueOf(this.userTime_) + "],");
buffer.append("[systemTime: " + String.valueOf(this.systemTime_) + "],");
buffer.append("[processId: " + String.valueOf(this.processId_) + "],");
buffer.append("[mallocArenaBytes: " + String.valueOf(this.mallocArenaBytes_) + "],");
buffer.append("[mallocOrdBlocks: " + String.valueOf(this.mallocOrdBlocks_) + "],");
buffer.append("[mallocMmapBlocks: " + String.valueOf(this.mallocMmapBlocks_) + "],");
buffer.append("[mallocMmapBytes: " + String.valueOf(this.mallocMmapBytes_) + "],");
buffer.append("[mallocActiveBytes: " + String.valueOf(this.mallocActiveBytes_) + "],");
buffer.append("[mallocFreeBytes: " + String.valueOf(this.mallocFreeBytes_) + "],");
buffer.append("[mallocKeepCostBytes: " + String.valueOf(this.mallocKeepCostBytes_) + "],");
buffer.append("[heapTotalBytes: " + String.valueOf(this.heapTotalBytes_) + "],");
buffer.append("[processResidentBytes: " + String.valueOf(this.processResidentBytes_) + "],");
buffer.append("[numSynchronousReads: " + String.valueOf(this.numSynchronousReads_) + "],");
buffer.append("[synchronousReadMillisec: " + String.valueOf(this.synchronousReadMillisec_) + "],");
buffer.append("[numSynchronousReadBytes: " + String.valueOf(this.numSynchronousReadBytes_) + "],");
buffer.append("[numSynchronousWrites: " + String.valueOf(this.numSynchronousWrites_) + "],");
buffer.append("[synchronousWriteMillisec: " + String.valueOf(this.synchronousWriteMillisec_) + "],");
buffer.append("[numSynchronousWriteBytes: " + String.valueOf(this.numSynchronousWriteBytes_) + "],");
buffer.append("[numAsynchronousReads: " + String.valueOf(this.numAsynchronousReads_) + "],");
buffer.append("[asynchronousReadMillisec: " + String.valueOf(this.asynchronousReadMillisec_) + "],");
buffer.append("[numAsynchronousReadBytes: " + String.valueOf(this.numAsynchronousReadBytes_) + "],");
buffer.append("[numAsynchronousWrites: " + String.valueOf(this.numAsynchronousWrites_) + "],");
buffer.append("[asynchronousWriteMillisec: " + String.valueOf(this.asynchronousWriteMillisec_) + "],");
buffer.append("[numAsynchronousWriteBytes: " + String.valueOf(this.numAsynchronousWriteBytes_) + "],");
return buffer.toString();
}
public String serverName() {
return this.serverName_;
}
public String serverEdition() {
return this.serverEdition_;
}
public int buildNumber() {
return this.buildNumber_;
}
public int ippLowVersionMinor() {
return this.ippLowVersionMinor_;
}
public int ippLowVersionMajor() {
return this.ippLowVersionMajor_;
}
public int ippHighVersionMinor() {
return this.ippHighVersionMinor_;
}
public int ippHighVersionMajor() {
return this.ippHighVersionMajor_;
}
public String serverOsName() {
return this.serverOsName_;
}
public boolean is64Bit() {
return this.is64Bit_;
}
public boolean imageRenderingAvailable() {
return this.imageRenderingAvailable_;
}
public int imageRenderingSchema() {
return this.imageRenderingSchema_;
}
public long uptime() {
return this.uptime_;
}
public long serverBuildDate() {
return this.serverBuildDate_;
}
public int numClients() {
return this.numClients_;
}
public int clientOverlap() {
return this.clientOverlap_;
}
public long imagesServed() {
return this.imagesServed_;
}
public long pixelsServed() {
return this.pixelsServed_;
}
public long imageBytesServed() {
return this.imageBytesServed_;
}
public long totalBytesServed() {
return this.totalBytesServed_;
}
public long userTime() {
return this.userTime_;
}
public long systemTime() {
return this.systemTime_;
}
public long processId() {
return this.processId_;
}
public long mallocArenaBytes() {
return this.mallocArenaBytes_;
}
public long mallocOrdBlocks() {
return this.mallocOrdBlocks_;
}
public long mallocMmapBlocks() {
return this.mallocMmapBlocks_;
}
public long mallocMmapBytes() {
return this.mallocMmapBytes_;
}
public long mallocActiveBytes() {
return this.mallocActiveBytes_;
}
public long mallocFreeBytes() {
return this.mallocFreeBytes_;
}
public long mallocKeepCostBytes() {
return this.mallocKeepCostBytes_;
}
public long heapTotalBytes() {
return this.heapTotalBytes_;
}
public long processResidentBytes() {
return this.processResidentBytes_;
}
public int numSynchronousReads() {
return this.numSynchronousReads_;
}
public int synchronousReadMillisec() {
return this.synchronousReadMillisec_;
}
public int numSynchronousReadBytes() {
return this.numSynchronousReadBytes_;
}
public int numSynchronousWrites() {
return this.numSynchronousWrites_;
}
public int synchronousWriteMillisec() {
return this.synchronousWriteMillisec_;
}
public int numSynchronousWriteBytes() {
return this.numSynchronousWriteBytes_;
}
public int numAsynchronousReads() {
return this.numAsynchronousReads_;
}
public int asynchronousReadMillisec() {
return this.asynchronousReadMillisec_;
}
public int numAsynchronousReadBytes() {
return this.numAsynchronousReadBytes_;
}
public int numAsynchronousWrites() {
return this.numAsynchronousWrites_;
}
public int asynchronousWriteMillisec() {
return this.asynchronousWriteMillisec_;
}
public int numAsynchronousWriteBytes() {
return this.numAsynchronousWriteBytes_;
}
}