User:Jdev/Code/TimeProfiler

package lxx.utils.time_profiling;
 
import lxx.utils.ValueInfo;
 
import static java.lang.StrictMath.max;
 
public enum TimeProfile {
 
    TURN_TIME;
 
    private ValueInfo battleProfile;
    private ValueInfo roundProfile;
    private ValueInfo turnProfile;
 
    private long startTime = -1;
 
    public void start() {
        if (startTime != -1) {
            System.out.printf("[WARN] %s: Stop was not called\n", this.name());
            return;
        }
        startTime = System.nanoTime();
    }
 
    public void stop() {
        if (startTime == -1) {
            System.out.printf("[WARN] %s: Start was not called\n", this.name());
            return;
        }
        final long time = System.nanoTime() - startTime;
        battleProfile.addValue(time);
        roundProfile.addValue(time);
        turnProfile.addValue(time);
        startTime = -1;
    }
 
    public static void initBattle() {
        for (TimeProfile tp : values()) {
            tp.battleProfile = new ValueInfo(1500000);
        }
    }
 
    public static void initRound() {
        for (TimeProfile tp : values()) {
            tp.roundProfile = new ValueInfo(60000);
        }
    }
 
    public static void initTurn() {
        for (TimeProfile tp : values()) {
            tp.turnProfile = new ValueInfo(300);
        }
    }
 
    public static String getBattleProfilesString() {
        final StringBuilder res = new StringBuilder(" == Battle Time Profiles == \n");
        int maxPropertyNameLength = getMaxNameLen();
        for (TimeProfile tp : values()) {
            res.append(" ").append(String.format("%" + maxPropertyNameLength + "s", tp.name())).append(": ").append(tp.battleProfile.toString()).append("\n");
        }
        return res.toString();
    }
 
    public static String getRoundProfilesString() {
        final StringBuilder res = new StringBuilder(" == Round Time Profiles == \n");
        int maxPropertyNameLength = getMaxNameLen();
        for (TimeProfile tp : values()) {
            res.append(" ").append(String.format("%" + maxPropertyNameLength + "s", tp.name())).append(": ").append(tp.roundProfile.toString()).append("\n");
        }
        return res.toString();
    }
 
    public static String getTurnProfilesString() {
        final StringBuilder res = new StringBuilder(" == Turn Time Profiles == \n");
        int maxPropertyNameLength = getMaxNameLen();
        for (TimeProfile tp : values()) {
            res.append(" ").append(String.format("%" + maxPropertyNameLength + "s", tp.name())).append(": ").append(tp.turnProfile.toString()).append("\n");
        }
        return res.toString();
    }
 
    private static int getMaxNameLen() {
        int maxNameLen = 0;
 
        for (TimeProfile tp : values()) {
            maxNameLen = max(maxNameLen, tp.name().length());
        }
 
        return maxNameLen;
    }
 
}
 
package lxx.utils;
 
import static java.lang.Math.max;
import static java.lang.StrictMath.min;
 
public class ValueInfo {
 
    private final AvgValue avgValue;
    private double maxValue = Long.MIN_VALUE;
    private double minValue = Long.MAX_VALUE;
    private double total;
 
    public ValueInfo(int deph) {
        avgValue = new AvgValue(deph);
    }
 
    public void addValue(double value) {
        maxValue = max(maxValue, value);
        minValue = min(minValue, value);
        avgValue.addValue(value);
        total += value;
    }
 
    @Override
    public String toString() {
        if (maxValue == Long.MIN_VALUE) {
            return "[ No Data ]";
        } else if (maxValue == minValue) {
            return String.format("[ %,14.0f ]", minValue);
        } else {
            return String.format("[ %,9.0f | %,9.0f | %,14.0f | %,20.0f]", minValue, avgValue.getCurrentValue(), maxValue, total);
        }
    }
}
 
package lxx.utils;
 
import static java.lang.Math.min;
 
public class AvgValue {
 
    private final double[] values;
    private final int depth;
    private int valuesCount;
    private double currentSum;
    private double currentValue;
 
    public AvgValue(int depth) {
        this.depth = depth;
        values = new double[depth];
    }
 
    public void addValue(double newValue) {
        currentSum = currentSum - values[valuesCount % values.length] + newValue;
        values[valuesCount % values.length] = newValue;
        valuesCount++;
        currentValue = currentSum / min(valuesCount, depth);
    }
 
    public double getCurrentValue() {
        return currentValue;
    }
 
    public String toString() {
        return String.format("Avg value = %10.5f", getCurrentValue());
    }
}

public class TPRobot extends AdvancedRobot {
 
    static {
        TimeProfile.initBattle();
    }
 
    public void run() {
        TimeProfile.initRound();
        while (true) {
            TimeProfile.initTurn();
            TimeProfile.TURN_TIME.start();
            // robot code
            TimeProfile.TURN_TIME.stop();
            execute();
        }
    }
 
    public void onDeath(DeathEvent event) {
        System.out.println(TimeProfile.getRoundProfilesString());
        System.out.println(TimeProfile.getBattleProfilesString());
    }
 
    public void onWin(WinEvent event) {
        System.out.println(TimeProfile.getRoundProfilesString());
        System.out.println(TimeProfile.getBattleProfilesString());
    }
 
    public void onSkippedTurn(SkippedTurnEvent event) {
        System.out.println(TimeProfile.getTurnProfilesString());
    }
 
}