5005831: String constructors and method which take Charset rather than String as argument

introduced new constructors for String that take a Charset.
One would expect that these would be
uniformly faster than the equivalent constructors that take a String,
since the Charset lookup can be elided.

However, it appears that special String-based name optimizations in StringCoding foil that.

For the particular important case of ASCII or Latin-1 text,
we want to discourage the use of the deprecated constructors,
but the benchmark numbers cannot support such a recommendation.

The slowdown is only for small strings, of course.

Here's a microbenchmark, and a sample run:
----------------------------------------------------
import java.nio.*;
import java.nio.charset.*;
import java.util.*;
import java.util.concurrent.*;

public class Latin1StringMicroBenchmark {
    abstract static class Job {
private final String name;
public Job(String name) { this.name = name; }
public String name() { return name; }
public abstract void work() throws Throwable;
    }

    private static final long SECOND = 1000L*1000L*1000L;

    private static void collectAllGarbage() {
try {
for (int i = 0; i < 2; i++) {
System.gc();
Thread.sleep(10);
System.runFinalization();
Thread.sleep(10);
}
} catch (InterruptedException e) { throw new Error(e); }
    }

    /**
     * Runs each job for at least 10 seconds.
     * Returns array of average times per job per run.
     */
    private static long[] time0(Job ... jobs) throws Throwable {
long[] nanoss = new long[jobs.length];
for (int i = 0; i < jobs.length; i++) {
collectAllGarbage();
long t0 = System.nanoTime();
long t;
int j = 0;
do { jobs[i].work(); j++; }
while ((t = System.nanoTime() - t0) < 10L * SECOND);
nanoss[i] = t/j;
}
return nanoss;
    }

    private static void time(Job ... jobs) throws Throwable {

long[] warmup = time0(jobs); // Warm up run
long[] nanoss = time0(jobs); // Real timing run

final String nameHeader = "Method";
int nameWidth = nameHeader.length();
for (Job job : jobs)
nameWidth = Math.max(nameWidth, job.name().length());

final String millisHeader = "Millis";
int millisWidth = millisHeader.length();
for (long nanos : nanoss)
millisWidth =
Math.max(millisWidth,
String.format("%d", nanos/(1000L * 1000L)).length());

final String ratioHeader = "Ratio";
int ratioWidth = ratioHeader.length();

String format = String.format("%%-%ds %%%dd %%.3f%%n",
nameWidth, millisWidth);
String headerFormat = String.format("%%-%ds %%-%ds %%-%ds%%n",
nameWidth, millisWidth, ratioWidth);
System.out.printf(headerFormat, "Method", "Millis", "Ratio");

// Print out absolute and relative times, calibrated against first job
for (int i = 0; i < jobs.length; i++) {
long millis = nanoss[i]/(1000L * 1000L);
double ratio = (double)nanoss[i] / (double)nanoss[0];
System.out.printf(format, jobs[i].name(), millis, ratio);
}
    }

    private static int intArg(String[] args, int i, int defaultValue) {
return args.length > i ? Integer.parseInt(args[i]) : defaultValue;
    }

    public static void main(String[] args) throws Throwable {
final int length = intArg(args, 0, 1000);
final int iterations = intArg(args, 1, (int) (100000L * 1000L/length));

final byte[] latin1Bytes = new byte[length];
new Random().nextBytes(latin1Bytes);
final String expected = new String(latin1Bytes, "ISO-8859-1");
final String[] out = new String[1];
out[0] = "poopie";

time(
new Job("String(byte[], int hibyte)") {
@SuppressWarnings("deprecation")
public void work() throws Throwable {
for (int i = 0; i < iterations; i++) {
out[0] = new String(latin1Bytes, 0);
}
if (! out[0].equals(expected)) throw new Error();
}},
new Job("String(char[], int offset, int length)") {
public void work() throws Throwable {
char[] chars = new char[2*length];
for (int i = 0; i < iterations; i++) {
for (int j = 0; j < latin1Bytes.length; j++)
chars[j] = (char) (latin1Bytes[j] & 0xff);
out[0] = new String(chars, 0, latin1Bytes.length);
}
if (! out[0].equals(expected)) throw new Error();
}},
new Job("String(byte[], Charset cs)") {
public void work() throws Throwable {
Charset cs = Charset.forName("ISO-8859-1");
for (int i = 0; i < iterations; i++) {
out[0] = new String(latin1Bytes, cs);
}
if (! out[0].equals(expected)) throw new Error();
}},
new Job("String(byte[], String csn)") {
public void work() throws Throwable {
for (int i = 0; i < iterations; i++) {
out[0] = new String(latin1Bytes, "ISO-8859-1");
}
if (! out[0].equals(expected)) throw new Error();
}},
new Job("CharsetDecoder.decode(ByteBuffer, CharBuffer, true)") {
public void work() throws Throwable {
CharBuffer cb = CharBuffer.allocate(2*length);
CharsetDecoder coder =
Charset.forName("ISO-8859-1").newDecoder();
for (int i = 0; i < iterations; i++) {
ByteBuffer bb = ByteBuffer.wrap(latin1Bytes);
cb.clear();
coder.decode(bb, cb, true);
cb.flip();
out[0] = cb.toString();
}
if (! out[0].equals(expected)) throw new Error();
}}
);
    }
}
-------------------------------------------------------
 ~/src/toy $ for size in 1 10 100 1000; do echo $size -----; jver mustang jr Latin1StringMicroBenchmark $size; done
1 -----
==> javac -source 1.6 -Xlint:all Latin1StringMicroBenchmark.java
==> java -esa -ea Latin1StringMicroBenchmark 1
Method Millis Ratio
String(byte[], int hibyte) 12413 1.000
String(char[], int offset, int length) 12360 0.996
String(byte[], Charset cs) 111204 8.959
String(byte[], String csn) 63524 5.118
CharsetDecoder.decode(ByteBuffer, CharBuffer, true) 47278 3.809
10 -----
==> javac -source 1.6 -Xlint:all Latin1StringMicroBenchmark.java
==> java -esa -ea Latin1StringMicroBenchmark 10
Method Millis Ratio
String(byte[], int hibyte) 1805 1.000
String(char[], int offset, int length) 2622 1.452
String(byte[], Charset cs) 11342 6.282
String(byte[], String csn) 6688 3.704
CharsetDecoder.decode(ByteBuffer, CharBuffer, true) 5118 2.834
100 -----
==> javac -source 1.6 -Xlint:all Latin1StringMicroBenchmark.java
==> java -esa -ea Latin1StringMicroBenchmark 100
Method Millis Ratio
String(byte[], int hibyte) 1061 1.000
String(char[], int offset, int length) 1183 1.114
String(byte[], Charset cs) 1964 1.850
String(byte[], String csn) 1471 1.386
CharsetDecoder.decode(ByteBuffer, CharBuffer, true) 1461 1.377
1000 -----
==> javac -source 1.6 -Xlint:all Latin1StringMicroBenchmark.java
==> java -esa -ea Latin1StringMicroBenchmark 1000
Method Millis Ratio
String(byte[], int hibyte) 1066 1.000
String(char[], int offset, int length) 1000 0.938
String(byte[], Charset cs) 1044 0.979
String(byte[], String csn) 963 0.903
CharsetDecoder.decode(ByteBuffer, CharBuffer, true) 1058 0.992