/*
* Copyright (C) 2010-2011 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.perftest;
import java.io.Writer;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import android.os.Environment;
import android.content.res.Resources;
import android.renderscript.*;
import android.renderscript.Element.DataKind;
import android.renderscript.Element.DataType;
import android.renderscript.Allocation.MipmapControl;
import android.renderscript.Program.TextureType;
import android.renderscript.RenderScript.RSMessageHandler;
import android.renderscript.Sampler.Value;
import android.renderscript.Mesh.Primitive;
import android.renderscript.Matrix4f;
import android.renderscript.ProgramVertexFixedFunction;
import android.util.Log;
public class RsBenchRS {
private static final String TAG = "RsBenchRS";
int mWidth;
int mHeight;
int mLoops;
int mCurrentLoop;
int mBenchmarkDimX;
int mBenchmarkDimY;
public RsBenchRS() {
}
public void init(RenderScriptGL rs, Resources res, int width, int height, int loops) {
mRS = rs;
mRes = res;
mWidth = width;
mHeight = height;
mMode = 0;
mLoops = loops;
mCurrentLoop = 0;
mBenchmarkDimX = 1280;
mBenchmarkDimY = 720;
initRS();
}
private boolean stopTest = false;
private Resources mRes;
private RenderScriptGL mRS;
private ProgramStore mProgStoreBlendNone;
private ProgramStore mProgStoreBlendAlpha;
private ProgramFragment mProgFragmentTexture;
private ProgramFragment mProgFragmentColor;
private ProgramVertex mProgVertex;
private ProgramVertexFixedFunction.Constants mPVA;
private ProgramVertexFixedFunction.Constants mPvProjectionAlloc;
private ScriptC_rsbench mScript;
ScriptField_TestScripts_s.Item[] mIndividualTests;
int mMode;
String[] mTestNames;
float[] mLocalTestResults;
static Allocation createZeroTerminatedAlloc(RenderScript rs,
String str,
int usage) {
byte[] allocArray = null;
try {
allocArray = str.getBytes("UTF-8");
byte[] allocArrayZero = new byte[allocArray.length + 1];
System.arraycopy(allocArray, 0, allocArrayZero, 0, allocArray.length);
allocArrayZero[allocArrayZero.length - 1] = '\0';
Allocation alloc = Allocation.createSized(rs, Element.U8(rs),
allocArrayZero.length, usage);
alloc.copyFrom(allocArrayZero);
return alloc;
}
catch (Exception e) {
throw new RSRuntimeException("Could not convert string to utf-8.");
}
}
void appendTests(RsBenchBaseTest testSet) {
ScriptField_TestScripts_s.Item[] newTests = testSet.getTests();
if (mIndividualTests != null) {
ScriptField_TestScripts_s.Item[] combined;
combined = new ScriptField_TestScripts_s.Item[newTests.length + mIndividualTests.length];
System.arraycopy(mIndividualTests, 0, combined, 0, mIndividualTests.length);
System.arraycopy(newTests, 0, combined, mIndividualTests.length, newTests.length);
mIndividualTests = combined;
} else {
mIndividualTests = newTests;
}
String[] newNames = testSet.getTestNames();
if (mTestNames != null) {
String[] combinedNames;
combinedNames = new String[newNames.length + mTestNames.length];
System.arraycopy(mTestNames, 0, combinedNames, 0, mTestNames.length);
System.arraycopy(newNames, 0, combinedNames, mTestNames.length, newNames.length);
mTestNames = combinedNames;
} else {
mTestNames = newNames;
}
}
void createTestAllocation() {
int numTests = mIndividualTests.length;
mLocalTestResults = new float[numTests];
ScriptField_TestScripts_s allTests;
allTests = new ScriptField_TestScripts_s(mRS, numTests);
for (int i = 0; i < numTests; i ++) {
allTests.set(mIndividualTests[i], i, false);
}
allTests.copyAll();
mScript.bind_gTestScripts(allTests);
}
private void saveTestResults() {
String state = Environment.getExternalStorageState();
if (!Environment.MEDIA_MOUNTED.equals(state)) {
Log.v(TAG, "sdcard is read only");
return;
}
File sdCard = Environment.getExternalStorageDirectory();
if (!sdCard.canWrite()) {
Log.v(TAG, "ssdcard is read only");
return;
}
File resultFile = new File(sdCard, "rsbench_result" + mCurrentLoop + ".csv");
resultFile.setWritable(true, false);
try {
BufferedWriter results = new BufferedWriter(new FileWriter(resultFile));
for (int i = 0; i < mLocalTestResults.length; i ++) {
results.write(mTestNames[i] + ", " + mLocalTestResults[i] + ",\n");
}
results.close();
Log.v(TAG, "Saved results in: " + resultFile.getAbsolutePath());
} catch (IOException e) {
Log.v(TAG, "Unable to write result file " + e.getMessage());
}
}
/**
* Create a message handler to handle message sent from the script
*/
protected RSMessageHandler mRsMessage = new RSMessageHandler() {
public void run() {
if (mID == mScript.get_RS_MSG_RESULTS_READY()) {
for (int i = 0; i < mLocalTestResults.length; i ++) {
mLocalTestResults[i] = Float.intBitsToFloat(mData[i]);
}
saveTestResults();
if (mLoops > 0) {
mCurrentLoop ++;
mCurrentLoop = mCurrentLoop % mLoops;
}
return;
} else if (mID == mScript.get_RS_MSG_TEST_DONE()) {
synchronized(this) {
stopTest = true;
this.notifyAll();
}
return;
} else {
Log.v(TAG, "Perf test got unexpected message");
return;
}
}
};
/**
* Wait for message from the script
*/
public boolean testIsFinished() {
synchronized(this) {
while (true) {
if (stopTest) {
return true;
} else {
try {
this.wait(60*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
private void initProgramFragment() {
ProgramFragmentFixedFunction.Builder texBuilder = new ProgramFragmentFixedFunction.Builder(mRS);
texBuilder.setTexture(ProgramFragmentFixedFunction.Builder.EnvMode.REPLACE,
ProgramFragmentFixedFunction.Builder.Format.RGBA, 0);
mProgFragmentTexture = texBuilder.create();
mProgFragmentTexture.bindSampler(Sampler.CLAMP_LINEAR(mRS), 0);
ProgramFragmentFixedFunction.Builder colBuilder = new ProgramFragmentFixedFunction.Builder(mRS);
colBuilder.setVaryingColor(false);
mProgFragmentColor = colBuilder.create();
mScript.set_gProgFragmentTexture(mProgFragmentTexture);
}
private void initProgramVertex() {
ProgramVertexFixedFunction.Builder pvb = new ProgramVertexFixedFunction.Builder(mRS);
mProgVertex = pvb.create();
mPVA = new ProgramVertexFixedFunction.Constants(mRS);
((ProgramVertexFixedFunction)mProgVertex).bindConstants(mPVA);
Matrix4f proj = new Matrix4f();
proj.loadOrthoWindow(mBenchmarkDimX, mBenchmarkDimY);
mPVA.setProjection(proj);
mScript.set_gProgVertex(mProgVertex);
}
private int strlen(byte[] array) {
int count = 0;
while(count < array.length && array[count] != 0) {
count ++;
}
return count;
}
public void setDebugMode(int num) {
mScript.invoke_setDebugMode(num);
}
public void setBenchmarkMode(int benchNum) {
mScript.invoke_setBenchmarkMode(benchNum);
}
public void pause(boolean pause) {
mScript.set_gPauseRendering(pause);
}
private void initRS() {
mScript = new ScriptC_rsbench(mRS, mRes, R.raw.rsbench);
mRS.bindRootScript(mScript);
mRS.setMessageHandler(mRsMessage);
mScript.set_gMaxLoops(mLoops);
initProgramVertex();
initProgramFragment();
mScript.set_gFontSerif(Font.create(mRS, mRes, "serif", Font.Style.NORMAL, 8));
Type.Builder b = new Type.Builder(mRS, Element.RGBA_8888(mRS));
b.setX(mBenchmarkDimX).setY(mBenchmarkDimY);
Allocation offscreen = Allocation.createTyped(mRS,
b.create(),
Allocation.USAGE_GRAPHICS_TEXTURE |
Allocation.USAGE_GRAPHICS_RENDER_TARGET);
mScript.set_gRenderBufferColor(offscreen);
b = new Type.Builder(mRS,
Element.createPixel(mRS, DataType.UNSIGNED_16,
DataKind.PIXEL_DEPTH));
b.setX(mBenchmarkDimX).setY(mBenchmarkDimY);
offscreen = Allocation.createTyped(mRS,
b.create(),
Allocation.USAGE_GRAPHICS_RENDER_TARGET);
mScript.set_gRenderBufferDepth(offscreen);
mScript.set_gLinearClamp(Sampler.CLAMP_LINEAR(mRS));
RsBenchBaseTest test = new TextTest();
if (test.init(mRS, mRes)) {
appendTests(test);
}
test = new FillTest();
if (test.init(mRS, mRes)) {
appendTests(test);
}
test = new MeshTest();
if (test.init(mRS, mRes)) {
appendTests(test);
}
test = new TorusTest();
if (test.init(mRS, mRes)) {
appendTests(test);
}
test = new UiTest();
if (test.init(mRS, mRes)) {
appendTests(test);
}
createTestAllocation();
mScript.set_gLoadComplete(true);
}
}
|
