// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
package org.chromium.net;
import android.app.Activity;
import android.net.Uri;
import android.os.Bundle;
import android.os.Debug;
import org.json.JSONException;
import org.json.JSONObject;
import org.chromium.base.ContextUtils;
import org.chromium.base.PathUtils;
import org.chromium.base.task.PostTask;
import org.chromium.base.task.TaskTraits;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
/** Runs networking benchmarks and saves results to a file. */
public class CronetPerfTestActivity extends Activity {
private static final String PRIVATE_DATA_DIRECTORY_SUFFIX = "cronet_perf_test";
// Benchmark configuration passed down from host via Intent data.
// Call getConfig*(key) to extract individual configuration values.
private Uri mConfig;
// Functions that retrieve individual benchmark configuration values.
private String getConfigString(String key) {
return mConfig.getQueryParameter(key);
}
private int getConfigInt(String key) {
return Integer.parseInt(mConfig.getQueryParameter(key));
}
private boolean getConfigBoolean(String key) {
return Boolean.parseBoolean(mConfig.getQueryParameter(key));
}
private enum Mode {
SYSTEM_HUC, // Benchmark system HttpURLConnection
CRONET_HUC, // Benchmark Cronet's HttpURLConnection
CRONET_ASYNC, // Benchmark Cronet's asynchronous API
}
private enum Direction {
UP, // Benchmark upload (i.e. POST)
DOWN, // Benchmark download (i.e. GET)
}
private enum Size {
LARGE, // Large benchmark
SMALL, // Small benchmark
}
private enum Protocol {
HTTP,
QUIC,
}
// Put together a benchmark configuration into a benchmark name.
// Make it fixed length for more readable tables.
// Benchmark names are written to the JSON output file and slurped up by Telemetry on the host.
private static String buildBenchmarkName(
Mode mode, Direction direction, Protocol protocol, int concurrency, int iterations) {
String name = direction == Direction.UP ? "Up___" : "Down_";
switch (protocol) {
case HTTP:
name += "H_";
break;
case QUIC:
name += "Q_";
break;
default:
throw new IllegalArgumentException("Unknown protocol: " + protocol);
}
name += iterations + "_" + concurrency + "_";
switch (mode) {
case SYSTEM_HUC:
name += "SystemHUC__";
break;
case CRONET_HUC:
name += "CronetHUC__";
break;
case CRONET_ASYNC:
name += "CronetAsync";
break;
default:
throw new IllegalArgumentException("Unknown mode: " + mode);
}
return name;
}
// Responsible for running one particular benchmark and timing it.
private class Benchmark {
private final Mode mMode;
private final Direction mDirection;
private final Protocol mProtocol;
private final URL mUrl;
private final String mName;
private final CronetEngine mCronetEngine;
// Size in bytes of content being uploaded or downloaded.
private final int mLength;
// How many requests to execute.
private final int mIterations;
// How many requests to execute in parallel at any one time.
private final int mConcurrency;
// Dictionary of benchmark names mapped to times to complete the benchmarks.
private final JSONObject mResults;
// How large a buffer to use for passing content, in bytes.
private final int mBufferSize;
// Cached copy of getConfigBoolean("CRONET_ASYNC_USE_NETWORK_THREAD") for faster access.
private final boolean mUseNetworkThread;
private long mStartTimeMs = -1;
private long mStopTimeMs = -1;
/**
* Create a new benchmark to run. Sets up various configuration settings.
* @param mode The API to benchmark.
* @param direction The transfer direction to benchmark (i.e. upload or download).
* @param size The size of the transfers to benchmark (i.e. large or small).
* @param protocol The transfer protocol to benchmark (i.e. HTTP or QUIC).
* @param concurrency The number of transfers to perform concurrently.
* @param results Mapping of benchmark names to time required to run the benchmark in ms.
* When the benchmark completes this is updated with the result.
*/
public Benchmark(
Mode mode,
Direction direction,
Size size,
Protocol protocol,
int concurrency,
JSONObject results) {
mMode = mode;
mDirection = direction;
mProtocol = protocol;
final String resource;
switch (size) {
case SMALL:
resource = getConfigString("SMALL_RESOURCE");
mIterations = getConfigInt("SMALL_ITERATIONS");
mLength = getConfigInt("SMALL_RESOURCE_SIZE");
break;
case LARGE:
// When measuring a large upload, only download a small amount so download time
// isn't significant.
resource =
getConfigString(
direction == Direction.UP
? "SMALL_RESOURCE"
: "LARGE_RESOURCE");
mIterations = getConfigInt("LARGE_ITERATIONS");
mLength = getConfigInt("LARGE_RESOURCE_SIZE");
break;
default:
throw new IllegalArgumentException("Unknown size: " + size);
}
final String scheme;
final String host;
final int port;
switch (protocol) {
case HTTP:
scheme = "http";
host = getConfigString("HOST_IP");
port = getConfigInt("HTTP_PORT");
break;
case QUIC:
scheme = "https";
host = getConfigString("HOST");
port = getConfigInt("QUIC_PORT");
break;
default:
throw new IllegalArgumentException("Unknown protocol: " + protocol);
}
try {
mUrl = new URL(scheme, host, port, resource);
} catch (MalformedURLException e) {
throw new IllegalArgumentException(
"Bad URL: " + host + ":" + port + "/" + resource);
}
final ExperimentalCronetEngine.Builder cronetEngineBuilder =
new ExperimentalCronetEngine.Builder(CronetPerfTestActivity.this);
System.loadLibrary("cronet_tests");
if (mProtocol == Protocol.QUIC) {
cronetEngineBuilder.enableQuic(true);
cronetEngineBuilder.addQuicHint(host, port, port);
CronetTestUtil.setMockCertVerifierForTesting(
cronetEngineBuilder,
MockCertVerifier.createMockCertVerifier(
new String[] {getConfigString("QUIC_CERT_FILE")}, true));
}
try {
JSONObject hostResolverParams =
CronetTestUtil.generateHostResolverRules(getConfigString("HOST_IP"));
JSONObject experimentalOptions =
new JSONObject().put("HostResolverRules", hostResolverParams);
cronetEngineBuilder.setExperimentalOptions(experimentalOptions.toString());
} catch (JSONException e) {
throw new IllegalStateException("JSON failed: " + e);
}
mCronetEngine = cronetEngineBuilder.build();
mName = buildBenchmarkName(mode, direction, protocol, concurrency, mIterations);
mConcurrency = concurrency;
mResults = results;
mBufferSize =
mLength > getConfigInt("MAX_BUFFER_SIZE")
? getConfigInt("MAX_BUFFER_SIZE")
: mLength;
mUseNetworkThread = getConfigBoolean("CRONET_ASYNC_USE_NETWORK_THREAD");
}
private void startTimer() {
mStartTimeMs = System.currentTimeMillis();
}
private void stopTimer() {
mStopTimeMs = System.currentTimeMillis();
}
private void reportResult() {
if (mStartTimeMs == -1 || mStopTimeMs == -1) {
throw new IllegalStateException("startTimer() or stopTimer() not called");
}
try {
mResults.put(mName, mStopTimeMs - mStartTimeMs);
} catch (JSONException e) {
System.out.println("Failed to write JSON result for " + mName);
}
}
private void startLogging() {
if (getConfigBoolean("CAPTURE_NETLOG")) {
mCronetEngine.startNetLogToFile(
getFilesDir().getPath() + "/" + mName + ".json", false);
}
if (getConfigBoolean("CAPTURE_TRACE")) {
Debug.startMethodTracing(getFilesDir().getPath() + "/" + mName + ".trace");
} else if (getConfigBoolean("CAPTURE_SAMPLED_TRACE")) {
Debug.startMethodTracingSampling(
getFilesDir().getPath() + "/" + mName + ".trace", 8000000, 10);
}
}
private void stopLogging() {
if (getConfigBoolean("CAPTURE_NETLOG")) {
mCronetEngine.stopNetLog();
}
if (getConfigBoolean("CAPTURE_TRACE") || getConfigBoolean("CAPTURE_SAMPLED_TRACE")) {
Debug.stopMethodTracing();
}
}
/**
* Transfer {@code mLength} bytes through HttpURLConnection in {@code mDirection} direction.
* @param urlConnection The HttpURLConnection to use for transfer.
* @param buffer A buffer of length |mBufferSize| to use for transfer.
* @return {@code true} if transfer completed successfully.
*/
private boolean exerciseHttpURLConnection(URLConnection urlConnection, byte[] buffer)
throws IOException {
final HttpURLConnection connection = (HttpURLConnection) urlConnection;
try {
int bytesTransfered = 0;
if (mDirection == Direction.DOWN) {
final InputStream inputStream = connection.getInputStream();
while (true) {
final int bytesRead = inputStream.read(buffer, 0, mBufferSize);
if (bytesRead == -1) {
break;
} else {
bytesTransfered += bytesRead;
}
}
} else {
connection.setDoOutput(true);
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Length", Integer.toString(mLength));
final OutputStream outputStream = connection.getOutputStream();
for (int remaining = mLength; remaining > 0; remaining -= mBufferSize) {
outputStream.write(buffer, 0, Math.min(remaining, mBufferSize));
}
bytesTransfered = mLength;
}
return connection.getResponseCode() == 200 && bytesTransfered == mLength;
} finally {
connection.disconnect();
}
}
// GET or POST to one particular URL using URL.openConnection()
private class SystemHttpURLConnectionFetchTask implements Callable<Boolean> {
private final byte[] mBuffer = new byte[mBufferSize];
@Override
public Boolean call() {
try {
return exerciseHttpURLConnection(mUrl.openConnection(), mBuffer);
} catch (IOException e) {
System.out.println("System HttpURLConnection failed with " + e);
return false;
}
}
}
// GET or POST to one particular URL using Cronet HttpURLConnection API
private class CronetHttpURLConnectionFetchTask implements Callable<Boolean> {
private final byte[] mBuffer = new byte[mBufferSize];
@Override
public Boolean call() {
try {
return exerciseHttpURLConnection(mCronetEngine.openConnection(mUrl), mBuffer);
} catch (IOException e) {
System.out.println("Cronet HttpURLConnection failed with " + e);
return false;
}
}
}
// GET or POST to one particular URL using Cronet's asynchronous API
private class CronetAsyncFetchTask implements Callable<Boolean> {
// A message-queue for asynchronous tasks to post back to.
private final LinkedBlockingQueue<Runnable> mWorkQueue = new LinkedBlockingQueue<>();
private final WorkQueueExecutor mWorkQueueExecutor = new WorkQueueExecutor();
private int mRemainingRequests;
private int mConcurrentFetchersDone;
private boolean mFailed;
CronetAsyncFetchTask() {
mRemainingRequests = mIterations;
mConcurrentFetchersDone = 0;
mFailed = false;
}
private void initiateRequest(final ByteBuffer buffer) {
if (mRemainingRequests == 0) {
mConcurrentFetchersDone++;
if (mUseNetworkThread) {
// Post empty task so message loop exit condition is retested.
postToWorkQueue(
new Runnable() {
@Override
public void run() {}
});
}
return;
}
mRemainingRequests--;
final Runnable completionCallback =
new Runnable() {
@Override
public void run() {
initiateRequest(buffer);
}
};
final UrlRequest.Builder builder =
mCronetEngine.newUrlRequestBuilder(
mUrl.toString(),
new Callback(buffer, completionCallback),
mWorkQueueExecutor);
if (mDirection == Direction.UP) {
builder.setUploadDataProvider(new Uploader(buffer), mWorkQueueExecutor);
builder.addHeader("Content-Type", "application/octet-stream");
}
builder.build().start();
}
private class Uploader extends UploadDataProvider {
private final ByteBuffer mBuffer;
private int mRemainingBytes;
Uploader(ByteBuffer buffer) {
mBuffer = buffer;
mRemainingBytes = mLength;
}
@Override
public long getLength() {
return mLength;
}
@Override
public void read(UploadDataSink uploadDataSink, ByteBuffer byteBuffer) {
mBuffer.clear();
// Don't post more than |mLength|.
if (mRemainingBytes < mBuffer.limit()) {
mBuffer.limit(mRemainingBytes);
}
// Don't overflow |byteBuffer|.
if (byteBuffer.remaining() < mBuffer.limit()) {
mBuffer.limit(byteBuffer.remaining());
}
byteBuffer.put(mBuffer);
mRemainingBytes -= mBuffer.position();
uploadDataSink.onReadSucceeded(false);
}
@Override
public void rewind(UploadDataSink uploadDataSink) {
uploadDataSink.onRewindError(new Exception("no rewinding"));
}
}
private class Callback extends UrlRequest.Callback {
private final ByteBuffer mBuffer;
private final Runnable mCompletionCallback;
private int mBytesReceived;
Callback(ByteBuffer buffer, Runnable completionCallback) {
mBuffer = buffer;
mCompletionCallback = completionCallback;
}
@Override
public void onResponseStarted(UrlRequest request, UrlResponseInfo info) {
mBuffer.clear();
request.read(mBuffer);
}
@Override
public void onRedirectReceived(
UrlRequest request, UrlResponseInfo info, String newLocationUrl) {
request.followRedirect();
}
@Override
public void onReadCompleted(
UrlRequest request, UrlResponseInfo info, ByteBuffer byteBuffer) {
mBytesReceived += byteBuffer.position();
mBuffer.clear();
request.read(mBuffer);
}
@Override
public void onSucceeded(UrlRequest request, UrlResponseInfo info) {
if (info.getHttpStatusCode() != 200 || mBytesReceived != mLength) {
System.out.println(
"Failed: response code: "
+ info.getHttpStatusCode()
+ " bytes: "
+ mBytesReceived);
mFailed = true;
}
mCompletionCallback.run();
}
@Override
public void onFailed(UrlRequest request, UrlResponseInfo info, CronetException e) {
System.out.println("Async request failed with " + e);
mFailed = true;
}
}
private void postToWorkQueue(Runnable task) {
try {
mWorkQueue.put(task);
} catch (InterruptedException e) {
mFailed = true;
}
}
private class WorkQueueExecutor implements Executor {
@Override
public void execute(Runnable task) {
if (mUseNetworkThread) {
task.run();
} else {
postToWorkQueue(task);
}
}
}
@Override
public Boolean call() {
// Initiate concurrent requests.
for (int i = 0; i < mConcurrency; i++) {
initiateRequest(ByteBuffer.allocateDirect(mBufferSize));
}
// Wait for all jobs to finish.
try {
while (mConcurrentFetchersDone != mConcurrency && !mFailed) {
mWorkQueue.take().run();
}
} catch (InterruptedException e) {
System.out.println("Async tasks failed with " + e);
mFailed = true;
}
return !mFailed;
}
}
/** Executes the benchmark, times how long it takes, and records time in |mResults|. */
public void run() {
final ExecutorService executor = Executors.newFixedThreadPool(mConcurrency);
final List<Callable<Boolean>> tasks = new ArrayList<>(mIterations);
startLogging();
// Prepare list of tasks to run.
switch (mMode) {
case SYSTEM_HUC:
for (int i = 0; i < mIterations; i++) {
tasks.add(new SystemHttpURLConnectionFetchTask());
}
break;
case CRONET_HUC:
{
for (int i = 0; i < mIterations; i++) {
tasks.add(new CronetHttpURLConnectionFetchTask());
}
break;
}
case CRONET_ASYNC:
tasks.add(new CronetAsyncFetchTask());
break;
default:
throw new IllegalArgumentException("Unknown mode: " + mMode);
}
// Execute tasks.
boolean success = true;
List<Future<Boolean>> futures = new ArrayList<>();
try {
startTimer();
// If possible execute directly to lessen impact of thread-pool overhead.
if (tasks.size() == 1 || mConcurrency == 1) {
for (int i = 0; i < tasks.size(); i++) {
if (!tasks.get(i).call()) {
success = false;
}
}
} else {
futures = executor.invokeAll(tasks);
executor.shutdown();
executor.awaitTermination(240, TimeUnit.SECONDS);
}
stopTimer();
for (Future<Boolean> future : futures) {
if (!future.isDone() || !future.get()) {
success = false;
break;
}
}
} catch (Exception e) {
System.out.println("Batch execution failed with " + e);
success = false;
}
stopLogging();
if (success) {
reportResult();
}
}
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Initializing application context here due to lack of custom CronetPerfTestApplication.
ContextUtils.initApplicationContext(getApplicationContext());
PathUtils.setPrivateDataDirectorySuffix(PRIVATE_DATA_DIRECTORY_SUFFIX);
mConfig = getIntent().getData();
// Execute benchmarks on another thread to avoid networking on main thread.
PostTask.postTask(
TaskTraits.USER_BLOCKING,
() -> {
JSONObject results = new JSONObject();
for (Mode mode : Mode.values()) {
for (Direction direction : Direction.values()) {
for (Protocol protocol : Protocol.values()) {
if (protocol == Protocol.QUIC && mode == Mode.SYSTEM_HUC) {
// Unsupported; skip.
continue;
}
// Run large and small benchmarks one at a time to test
// single-threaded use.
// Also run them four at a time to see how they benefit from
// concurrency.
// The value four was chosen as many devices are now quad-core.
new Benchmark(mode, direction, Size.LARGE, protocol, 1, results)
.run();
new Benchmark(mode, direction, Size.LARGE, protocol, 4, results)
.run();
new Benchmark(mode, direction, Size.SMALL, protocol, 1, results)
.run();
new Benchmark(mode, direction, Size.SMALL, protocol, 4, results)
.run();
// Large benchmarks are generally bandwidth bound and unaffected by
// per-request overhead. Small benchmarks are not, so test at
// further increased concurrency to see if further benefit is
// possible.
new Benchmark(mode, direction, Size.SMALL, protocol, 8, results)
.run();
}
}
}
final File outputFile = new File(getConfigString("RESULTS_FILE"));
final File doneFile = new File(getConfigString("DONE_FILE"));
// If DONE_FILE exists, something is horribly wrong, produce no results to
// convey this.
if (doneFile.exists()) {
results = new JSONObject();
}
// Write out results to RESULTS_FILE, then create DONE_FILE.
FileOutputStream outputFileStream = null;
FileOutputStream doneFileStream = null;
try {
outputFileStream = new FileOutputStream(outputFile);
outputFileStream.write(results.toString().getBytes());
outputFileStream.close();
doneFileStream = new FileOutputStream(doneFile);
doneFileStream.close();
} catch (Exception e) {
System.out.println("Failed write results file: " + e);
} finally {
try {
if (outputFileStream != null) {
outputFileStream.close();
}
if (doneFileStream != null) {
doneFileStream.close();
}
} catch (IOException e) {
System.out.println("Failed to close output file: " + e);
}
}
finish();
});
}
}
Codebase Browser
chromium