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
|
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.tradefed.util;
import com.android.ddmlib.IShellOutputReceiver;
import com.android.tradefed.device.DeviceNotAvailableException;
import com.android.tradefed.device.ITestDevice;
import org.junit.Assert;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
* Utility class to dispatch simple command and collect results
* @see <a href="https://android.googlesource.com/platform/system/extras/+/master/simpleperf/">
* Introduction of simpleperf</a>
*/
public class SimplePerfUtil {
private ITestDevice mDevice;
private SimplePerfType mType;
private List<String> mArguList;
private StringBuilder mCachedCommandPrepend;
private SimplePerfUtil(ITestDevice device, SimplePerfType type) {
mDevice = device;
mType = type;
mCachedCommandPrepend = null;
}
/**
* SimplePerfUtil Constructor
* <p/>
* Caller must define device and simpleperf type when initializing instance
*
* @param device {@link ITestDevice} test device
* @param type {@link SimplePerfType} indicates which simpleperf mode
* @return a newly created SimplePerfUtil instance
*/
public static SimplePerfUtil newInstance(ITestDevice device, SimplePerfType type)
throws NullPointerException {
if (device == null || type == null) {
throw new NullPointerException();
}
return new SimplePerfUtil(device, type);
}
/**
* Get argument for simpleperf command
*
* @return list of subcommand and arguments (nullable)
*/
public List<String> getArgumentList() {
return mArguList;
}
/**
* Set argument on simpleperf command
*
* @param arguList list of subcommand and arguments
*/
public void setArgumentList(List<String> arguList) {
mArguList = arguList;
mCachedCommandPrepend = null;
}
/**
* Executes the given adb shell command, with simpleperf wrapped around
* <p/>
* Simpleperf result will be parsed and return to caller
*
* @param command command to run on device
* @return {@link SimplePerfResult} object contains all result information
* @throws DeviceNotAvailableException if connection with device is lost and cannot be
* recovered
*/
public SimplePerfResult executeCommand(String command) throws DeviceNotAvailableException {
String output = mDevice.executeShellCommand(commandStringPreparer(command));
Assert.assertNotNull("ExecuteShellCommand returns null", output);
return SimplePerfStatResultParser.parseRawOutput(output);
}
/**
* Executes the given adb shell command, with simpleperf wrapped around
* <p/>
* It is caller's responsibility to parse simpleperf result through receiver
*
* @param command command to run on device
* @param receiver {@link IShellOutputReceiver} object to direct shell output to
* @throws DeviceNotAvailableException if connection with device is lost and cannot be
* recovered
*/
public void executeCommand(String command, IShellOutputReceiver receiver)
throws DeviceNotAvailableException {
mDevice.executeShellCommand(commandStringPreparer(command), receiver);
}
/**
* Executes the given adb shell command, with simpleperf wrapped around
* <p/>
* It is caller's responsibility to parse simpleperf result through receiver
*
* @param command command to run on device
* @param receiver {@link IShellOutputReceiver} object to direct shell output to
* @param maxTimeToOutputShellResponse the maximum amount of time during which the command is
* allowed to not output any response; unit as specified in <code>timeUnit</code>
* @param timeUnit timeUnit unit for <code>maxTimeToOutputShellResponse</code>, see {@link
* TimeUnit}
* @param retryAttempts the maximum number of times to retry command if it fails due to a
* exception. DeviceNotResponsiveException will be thrown if <var>retryAttempts</var> are
* performed without success.
* @throws DeviceNotAvailableException if connection with device is lost and cannot be
* recovered
*/
public void executeCommand(String command, IShellOutputReceiver receiver,
long maxTimeToOutputShellResponse, TimeUnit timeUnit, int retryAttempts)
throws DeviceNotAvailableException {
mDevice.executeShellCommand(commandStringPreparer(command), receiver,
maxTimeToOutputShellResponse, timeUnit, retryAttempts);
}
protected String commandStringPreparer(String command) {
if (command == null) {
command = "";
}
return commandPrependPreparer().toString() + command;
}
private StringBuilder commandPrependPreparer() {
if (mCachedCommandPrepend == null) {
StringBuilder sb = new StringBuilder("simpleperf ");
sb.append(mType.toString()).append(" ");
if (mArguList != null) {
for (String argu : mArguList) {
sb.append(argu).append(" ");
}
}
mCachedCommandPrepend = sb;
}
return mCachedCommandPrepend;
}
/**
* Enum of simpleperf command options
*/
public enum SimplePerfType {
STAT("stat"),
REPORT("report"),
RECORD("record"),
LIST("list");
private final String text;
SimplePerfType(final String text) {
this.text = text;
}
@Override
public String toString() {
return text;
}
}
}
|
