path: root/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/BaseBenchmark.java

package org.linaro.iasenov.benchmarkframework;

import android.content.res.AssetManager;
import android.util.Log;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

/**
 * Created by iasenov on 8/22/16.
 */
public class BaseBenchmark {

    public String benchmarkName;
    public String version;
    public String date$;
    public String executable_name;
    public static long startTest;
    public static long endTest;
    public static double testTime;

    public List<String> TESTCOMMANDS;   //List with Specific test commands
    public String[] xout = new String[20];

    private String TAG = "BaseBenchmark";

    //List with All tests commands
    public List<String> ALLCOMMANDS = Arrays.asList(
            "harness -t bounce",
            "harness -t memchr",
            "harness -t memcpy",
            "harness -t memset",
            "harness -t strchr",
            "harness -t strcmp",
            "harness -t strcpy",
            "harness -t strlen",
            "dhry N",
//            "iozone -a -i 0 -b output.xls",
            "iozone -E -C 70 -L -S -W"


    );



    //**********************************************************************************************
    //Get all commands by executable_name
    //**********************************************************************************************
    public List<String> getCommands(String executable_name)
    {

        List<String> cmdListStr = new ArrayList<String>();
        int len = executable_name.length();

        for(String command: ALLCOMMANDS)
          {
              if(command.length() >= len) {

                  String subCmd = command.substring(0, len);
                  //Log.i(TAG, "subCmd: " + subCmd);

                  if (executable_name.equals(subCmd)) {
                      cmdListStr.add(command.substring(len + 1));
                      //Log.i(TAG, "add command: " + command.substring(len + 1));
                  }
              }
          }

        return cmdListStr;
    }



    //**********************************************************************************************
    //Clear test tags and result and fill version and date for the test
    //**********************************************************************************************
    public void clear() {
        Date today = Calendar.getInstance().getTime();
        SimpleDateFormat formatter = new SimpleDateFormat("dd-MMM-yyyy HH.mm");
        date$ = formatter.format(today);

        xout[0] = version + " " + date$ + "\n";    //Line for test version
        xout[1] = "\n";
        xout[2] = "\n";                            //Line for test labels
        xout[3] = "\n";                            //Line for test labels
        xout[4] = "\n";                            //Line for test labels
        xout[5] = "\n";                            //Line for test result
        xout[6] = "\n";                            //Line for test result
        xout[7] = "\n";                            //Line for test result
        xout[8] = "\n";                            //Line for test result
        xout[9] = "\n";                            //Line for test result
        xout[10] = "\n";                            //Line for test result
        xout[11] = "\n";                            //Line for test result
        xout[12] = "\n";                            //Line for test result
        xout[13] = "\n";                            //Line for test result
        xout[14] = "\n";                            //Line for test result
        xout[15] = "\n";
        xout[16] = "\n";                            //Line for total elapsed time
    }

    //**********************************************************************************************
    //return string with test result ready to be shown on TextView
    //**********************************************************************************************
    public String getBenchmarkResult(int elapsedTimeIdx) {
        testTime = (double) (endTest - startTest) / 1000;

        if(elapsedTimeIdx == -1)
        {
            elapsedTimeIdx = 16;
        }

        xout[15] = "\n";
        xout[elapsedTimeIdx] = "          Total Elapsed Time  " + String.format("%5.1f", testTime)
                + " seconds\n";

        return xout[0] + xout[1] + xout[2] + xout[3] +
                xout[4] + xout[5] + xout[6] + xout[7] +
                xout[8] + xout[9] + xout[10] + xout[11] +
                xout[12] + xout[13] + xout[14] + xout[15] +
                xout[16];
    }

    //**********************************************************************************************
    //This method is called from MainActivity for related(chosen) test
    //all test class that extend BaseBenchmark implement this method
    //**********************************************************************************************
    public String startBenchmark(int count) {
        return null;
    }

    //**********************************************************************************************
    //Read from logcat by selected "tag" and return string with all lines found
    //**********************************************************************************************
    public String readFromLogcat(String tag) {
        StringBuilder log = null;
        try {
            Process process = Runtime.getRuntime().exec("logcat -d -s " + tag);
            BufferedReader bufferedReader = new BufferedReader(
                    new InputStreamReader(process.getInputStream()));

            log = new StringBuilder();

            String separator = System.getProperty("line.separator");
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                line = line.replace("I/" + tag + "(", "");
                int index = line.indexOf(")");
                line = line.substring(index + 3);
                line = line.replace("null", "");
                log.append(line);
                log.append(separator);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return log.toString();
    }

    //**********************************************************************************************
    //Clear logcat
    //**********************************************************************************************
    public void clearLogcat() {
        try {
            Runtime.getRuntime().exec(new String[]{"logcat", "-c"});
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }


    //**********************************************************************************************
    //Read from log file (fill with logcat lines)  by selected "tag"
    //**********************************************************************************************
    public String readFromLogcatFile(String tag) {


        //Get the logcat text file
        File file = new File(MainActivity.LOG_PATH);

        //Read text from file
        StringBuilder text = new StringBuilder();

        try {
            BufferedReader br = new BufferedReader(new FileReader(file));
            String line;

            while ((line = br.readLine()) != null) {
                line = line.replace("I/" + tag + "(", "");
                int index = line.indexOf(")");
                line = line.substring(index + 3);
                line = line.replace("null", "");
                text.append(line);
                text.append('\n');
            }
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return text.toString();
    }


    //**********************************************************************************************
    //Copy file with InputStream "in" to file with OutputStream "out"
    //**********************************************************************************************
    public void copy(InputStream in, OutputStream out)
    {
        try {
            byte[] buffer = new byte[1024];
            int read;
            while ((read = in.read(buffer)) != -1) {
                out.write(buffer, 0, read);
            }
            in.close();
            in = null;

            // write the output file (You have now copied the file)
            out.flush();
            out.close();
            out = null;


        }  catch (FileNotFoundException fnfe1) {
            Log.i(TAG, fnfe1.getMessage());
        }
        catch (Exception e) {
            Log.i(TAG, e.getMessage());
        }

        Log.i(TAG, "Copy end");
    }





    //**********************************************************************************************
    //Copy "executable_filename" from assets to "EXECUTABLE_PATH" and execute this file
    //Return String from process's stdout
    //**********************************************************************************************
    public String copyAssetsExecFileAndRun(String executable_filename, List<String> TESTCOMMANDS) {

        String executableFilePath = MainActivity.EXECUTABLE_PATH;
        StringBuilder log = null;
        File dir_local = new File(executableFilePath);
        String currentCommand = "";
        String result = "";


        File dir = new File(executableFilePath);
        dir.mkdirs();

        AssetManager assetManager = MainActivity.mActivity.getAssets();

        InputStream in = null;
        OutputStream out = null;
        Log.d(TAG, "Attempting to copy this file: " + executable_filename);

        try {
            in = assetManager.open(executable_filename);

            Log.i(TAG, "outDir: " + executableFilePath);
            File outFile = new File(executableFilePath, executable_filename);

            out = new FileOutputStream(outFile);

            Log.i(TAG, "Copy begin");
            copy(in, out);

        } catch (IOException e) {
            Log.i(TAG, "Failed to copy asset file: " + executable_filename, e);
        }

        Log.i(TAG, "Copy success: " + executable_filename);

        if(TESTCOMMANDS.size() == 0) TESTCOMMANDS.add(""); //add empty command to run test once

        for(String command: TESTCOMMANDS) {
            currentCommand = command;

            try {

                File execFile = new File(executableFilePath + "/" + executable_filename);
                execFile.setExecutable(true);

                Process process = Runtime.getRuntime().exec(executableFilePath + "/" + executable_filename + " " + currentCommand, null, dir_local);
                Log.i(TAG, "process:" + process.toString());
                Log.i(TAG, "Execute: "+ executable_filename + " " + currentCommand);

                BufferedReader bufferedReader = new BufferedReader(
                        new InputStreamReader(process.getInputStream()));

                String separator = System.getProperty("line.separator");

                log = new StringBuilder();
                String line;
                while ((line = bufferedReader.readLine()) != null) {
                    line = line.replace("null", "");
                    log.append(line);
                    log.append(separator);
                    log.append(separator);
                    Log.i(TAG, "*****************" + line);
                }

                result = result + log.toString();
                process.destroy();

            } catch (Exception e) {
                Log.i(TAG, "Failed execute: " + executableFilePath + "/" + executable_filename, e);
            }
        }

        return result;
    }
//**********************************************************************************************
}//BaseBenchmark
//**********************************************************************************************