cleanup
This commit is contained in:
Bruce Eckel
parent
fb3544b632
commit
950a8b9303
@ -1,10 +0,0 @@
|
||||
//: annotations/ExtractInterface.java
|
||||
// javac-based annotation processing.
|
||||
package annotations;
|
||||
import java.lang.annotation.*;
|
||||
|
||||
@Target(ElementType.TYPE)
|
||||
@Retention(RetentionPolicy.SOURCE)
|
||||
public @interface ExtractInterface {
|
||||
public String value();
|
||||
} ///:~
|
||||
@ -1,68 +0,0 @@
|
||||
//: annotations/IfaceExtractorProcessor.java
|
||||
// javac-based annotation processing.
|
||||
package annotations;
|
||||
import javax.annotation.processing.*;
|
||||
import javax.lang.model.SourceVersion;
|
||||
import javax.lang.model.element.*;
|
||||
import java.util.*;
|
||||
import java.io.*;
|
||||
|
||||
@SupportedAnnotationTypes(
|
||||
"annotations.ExtractInterface")
|
||||
@SupportedSourceVersion(SourceVersion.RELEASE_8)
|
||||
public class IfaceExtractorProcessor
|
||||
extends AbstractProcessor {
|
||||
private ArrayList<Element>
|
||||
interfaceMethods = new ArrayList<>();
|
||||
private ProcessingEnvironment processingEnv;
|
||||
@Override public void
|
||||
init(ProcessingEnvironment processingEnv) {
|
||||
this.processingEnv = processingEnv;
|
||||
}
|
||||
@Override public boolean
|
||||
process(Set<? extends TypeElement> annotations,
|
||||
RoundEnvironment env) {
|
||||
for(Element elem :
|
||||
env.getElementsAnnotatedWith(ExtractInterface.class)) {
|
||||
if(elem.getModifiers().contains(Modifier.PUBLIC) &&
|
||||
!(elem.getModifiers().contains(Modifier.STATIC)))
|
||||
interfaceMethods.add(elem);
|
||||
if(interfaceMethods.size() > 0) {
|
||||
for(Element el : interfaceMethods)
|
||||
System.out.println(el.getKind() +
|
||||
" : " + el.getModifiers() +
|
||||
" : " + el.getSimpleName() +
|
||||
" : " + el.asType());
|
||||
try {
|
||||
try(Writer writer =
|
||||
processingEnv.getFiler()
|
||||
.createSourceFile("Filename.txt")
|
||||
.openWriter()) {
|
||||
/* writer.write("package " +
|
||||
typeDecl.getPackage().getQualifiedName() +";");
|
||||
writer.write("public interface " +
|
||||
annot.value() + " {");
|
||||
for(MethodDeclaration m : interfaceMethods) {
|
||||
writer.print(" public ");
|
||||
writer.print(m.getReturnType() + " ");
|
||||
writer.print(m.getSimpleName() + " (");
|
||||
int i = 0;
|
||||
for(ParameterDeclaration parm :
|
||||
m.getParameters()) {
|
||||
writer.print(parm.getType() + " " +
|
||||
parm.getSimpleName());
|
||||
if(++i < m.getParameters().size())
|
||||
writer.print(", ");
|
||||
}
|
||||
writer.write(");");
|
||||
}
|
||||
*/ writer.write("}");
|
||||
}
|
||||
} catch(Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
} ///:~
|
||||
@ -1,60 +0,0 @@
|
||||
//: annotations/InterfaceExtractorProcessor.java
|
||||
// APT-based annotation processing.
|
||||
// {CompileTimeError} Not working in Java 8
|
||||
// {Exec: apt -factory
|
||||
// annotations.InterfaceExtractorProcessorFactory
|
||||
// Multiplier.java -s ../annotations}
|
||||
package annotations;
|
||||
import com.sun.mirror.apt.*;
|
||||
import com.sun.mirror.declaration.*;
|
||||
import java.io.*;
|
||||
import java.util.*;
|
||||
|
||||
public class InterfaceExtractorProcessor
|
||||
implements AnnotationProcessor {
|
||||
private final AnnotationProcessorEnvironment env;
|
||||
private ArrayList<MethodDeclaration> interfaceMethods =
|
||||
new ArrayList<>();
|
||||
public InterfaceExtractorProcessor(
|
||||
AnnotationProcessorEnvironment env) { this.env = env; }
|
||||
public void process() {
|
||||
for(TypeDeclaration typeDecl :
|
||||
env.getSpecifiedTypeDeclarations()) {
|
||||
ExtractInterface annot =
|
||||
typeDecl.getAnnotation(ExtractInterface.class);
|
||||
if(annot == null)
|
||||
break;
|
||||
for(MethodDeclaration m : typeDecl.getMethods())
|
||||
if(m.getModifiers().contains(Modifier.PUBLIC) &&
|
||||
!(m.getModifiers().contains(Modifier.STATIC)))
|
||||
interfaceMethods.add(m);
|
||||
if(interfaceMethods.size() > 0) {
|
||||
try {
|
||||
try (PrintWriter writer = env.getFiler().createSourceFile(annot.value())) {
|
||||
writer.println("package " +
|
||||
typeDecl.getPackage().getQualifiedName() +";");
|
||||
writer.println("public interface " +
|
||||
annot.value() + " {");
|
||||
for(MethodDeclaration m : interfaceMethods) {
|
||||
writer.print(" public ");
|
||||
writer.print(m.getReturnType() + " ");
|
||||
writer.print(m.getSimpleName() + " (");
|
||||
int i = 0;
|
||||
for(ParameterDeclaration parm :
|
||||
m.getParameters()) {
|
||||
writer.print(parm.getType() + " " +
|
||||
parm.getSimpleName());
|
||||
if(++i < m.getParameters().size())
|
||||
writer.print(", ");
|
||||
}
|
||||
writer.println(");");
|
||||
}
|
||||
writer.println("}");
|
||||
}
|
||||
} catch(IOException ioe) {
|
||||
throw new RuntimeException(ioe);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} ///:~
|
||||
@ -1,23 +0,0 @@
|
||||
//: annotations/InterfaceExtractorProcessorFactory.java
|
||||
// APT-based annotation processing.
|
||||
// {CompileTimeError} Not working in Java 8
|
||||
package annotations;
|
||||
import com.sun.mirror.apt.*;
|
||||
import com.sun.mirror.declaration.*;
|
||||
import java.util.*;
|
||||
|
||||
public class InterfaceExtractorProcessorFactory
|
||||
implements AnnotationProcessorFactory {
|
||||
public AnnotationProcessor getProcessorFor(
|
||||
Set<AnnotationTypeDeclaration> atds,
|
||||
AnnotationProcessorEnvironment env) {
|
||||
return new InterfaceExtractorProcessor(env);
|
||||
}
|
||||
public Collection<String> supportedAnnotationTypes() {
|
||||
return
|
||||
Collections.singleton("annotations.ExtractInterface");
|
||||
}
|
||||
public Collection<String> supportedOptions() {
|
||||
return Collections.emptySet();
|
||||
}
|
||||
} ///:~
|
||||
@ -1,20 +0,0 @@
|
||||
//: annotations/Multiplier.java
|
||||
// javac-based annotation processing.
|
||||
package annotations;
|
||||
|
||||
@ExtractInterface("IMultiplier")
|
||||
public class Multiplier {
|
||||
public int multiply(int x, int y) {
|
||||
int total = 0;
|
||||
for(int i = 0; i < x; i++)
|
||||
total = add(total, y);
|
||||
return total;
|
||||
}
|
||||
private int add(int x, int y) { return x + y; }
|
||||
public static void main(String[] args) {
|
||||
Multiplier m = new Multiplier();
|
||||
System.out.println("11*16 = " + m.multiply(11, 16));
|
||||
}
|
||||
} /* Output:
|
||||
11*16 = 176
|
||||
*///:~
|
||||
@ -1,101 +0,0 @@
|
||||
//: annotations/database/TableCreationProcessorFactory.java
|
||||
// The database example using Visitor.
|
||||
// {CompileTimeError} Not working in Java 8
|
||||
// {Exec: apt -factory
|
||||
// annotations.database.TableCreationProcessorFactory
|
||||
// database/Member.java -s database}
|
||||
package annotations.database;
|
||||
import com.sun.mirror.apt.*;
|
||||
import com.sun.mirror.declaration.*;
|
||||
import com.sun.mirror.util.*;
|
||||
import java.util.*;
|
||||
import static com.sun.mirror.util.DeclarationVisitors.*;
|
||||
|
||||
public class TableCreationProcessorFactory
|
||||
implements AnnotationProcessorFactory {
|
||||
public AnnotationProcessor getProcessorFor(
|
||||
Set<AnnotationTypeDeclaration> atds,
|
||||
AnnotationProcessorEnvironment env) {
|
||||
return new TableCreationProcessor(env);
|
||||
}
|
||||
public Collection<String> supportedAnnotationTypes() {
|
||||
return Arrays.asList(
|
||||
"annotations.database.DBTable",
|
||||
"annotations.database.Constraints",
|
||||
"annotations.database.SQLString",
|
||||
"annotations.database.SQLInteger");
|
||||
}
|
||||
public Collection<String> supportedOptions() {
|
||||
return Collections.emptySet();
|
||||
}
|
||||
private static class TableCreationProcessor
|
||||
implements AnnotationProcessor {
|
||||
private final AnnotationProcessorEnvironment env;
|
||||
private String sql = "";
|
||||
public TableCreationProcessor(
|
||||
AnnotationProcessorEnvironment env) {
|
||||
this.env = env;
|
||||
}
|
||||
public void process() {
|
||||
for(TypeDeclaration typeDecl :
|
||||
env.getSpecifiedTypeDeclarations()) {
|
||||
typeDecl.accept(getDeclarationScanner(
|
||||
new TableCreationVisitor(), NO_OP));
|
||||
sql = sql.substring(0, sql.length() - 1) + ");";
|
||||
System.out.println("creation SQL is :\n" + sql);
|
||||
sql = "";
|
||||
}
|
||||
}
|
||||
private class TableCreationVisitor
|
||||
extends SimpleDeclarationVisitor {
|
||||
public void visitClassDeclaration(
|
||||
ClassDeclaration d) {
|
||||
DBTable dbTable = d.getAnnotation(DBTable.class);
|
||||
if(dbTable != null) {
|
||||
sql += "CREATE TABLE ";
|
||||
sql += (dbTable.name().length() < 1)
|
||||
? d.getSimpleName().toUpperCase()
|
||||
: dbTable.name();
|
||||
sql += " (";
|
||||
}
|
||||
}
|
||||
public void visitFieldDeclaration(
|
||||
FieldDeclaration d) {
|
||||
String columnName = "";
|
||||
if(d.getAnnotation(SQLInteger.class) != null) {
|
||||
SQLInteger sInt = d.getAnnotation(
|
||||
SQLInteger.class);
|
||||
// Use field name if name not specified
|
||||
if(sInt.name().length() < 1)
|
||||
columnName = d.getSimpleName().toUpperCase();
|
||||
else
|
||||
columnName = sInt.name();
|
||||
sql += "\n " + columnName + " INT" +
|
||||
getConstraints(sInt.constraints()) + ",";
|
||||
}
|
||||
if(d.getAnnotation(SQLString.class) != null) {
|
||||
SQLString sString = d.getAnnotation(
|
||||
SQLString.class);
|
||||
// Use field name if name not specified.
|
||||
if(sString.name().length() < 1)
|
||||
columnName = d.getSimpleName().toUpperCase();
|
||||
else
|
||||
columnName = sString.name();
|
||||
sql += "\n " + columnName + " VARCHAR(" +
|
||||
sString.value() + ")" +
|
||||
getConstraints(sString.constraints()) + ",";
|
||||
}
|
||||
}
|
||||
private String getConstraints(Constraints con) {
|
||||
String constraints = "";
|
||||
if(!con.allowNull())
|
||||
constraints += " NOT NULL";
|
||||
if(con.primaryKey())
|
||||
constraints += " PRIMARY KEY";
|
||||
if(con.unique())
|
||||
constraints += " UNIQUE";
|
||||
return constraints;
|
||||
}
|
||||
}
|
||||
}
|
||||
} ///:~
|
||||
@ -1,6 +0,0 @@
|
||||
# https://github.com/pypa/sampleproject/blob/master/setup.py
|
||||
|
||||
__all__ = ["CmdLine", "visitDir", "ruler", "head"]
|
||||
from betools.cmdline import CmdLine
|
||||
from betools.visitdir import visitDir
|
||||
from betools.ruler import ruler, head
|
||||
@ -1,38 +0,0 @@
|
||||
#! py -3
|
||||
"""
|
||||
Decorator adds a new command-line option and manages argparse.
|
||||
See http://www.artima.com/weblogs/viewpost.jsp?thread=240845
|
||||
"""
|
||||
import argparse
|
||||
|
||||
|
||||
class CmdLine:
|
||||
|
||||
parser = argparse.ArgumentParser()
|
||||
commands = dict()
|
||||
letterflags = set()
|
||||
|
||||
def __init__(self, letterFlag, wordFlag):
|
||||
self.wordFlag = wordFlag
|
||||
self.letterFlag = letterFlag
|
||||
assert wordFlag not in CmdLine.commands, "Duplicate command argument word flags"
|
||||
assert letterFlag not in CmdLine.letterflags, "Duplicate command argument letter flags"
|
||||
CmdLine.letterflags.add(letterFlag)
|
||||
|
||||
def __call__(self, func):
|
||||
CmdLine.parser.add_argument("-" + self.letterFlag, "--" + self.wordFlag, action='store_true', help=func.__doc__)
|
||||
CmdLine.commands[self.wordFlag] = func
|
||||
return func # No wrapping needed
|
||||
|
||||
@staticmethod
|
||||
def run():
|
||||
show_help = True
|
||||
args = vars(CmdLine.parser.parse_args())
|
||||
for wordFlag, func in CmdLine.commands.items():
|
||||
if args[wordFlag]:
|
||||
func()
|
||||
show_help = False
|
||||
if show_help:
|
||||
CmdLine.parser.print_help()
|
||||
|
||||
|
||||
@ -1,18 +0,0 @@
|
||||
#! python
|
||||
"""
|
||||
ruler() generates a string ruler with embedded text
|
||||
head() does the same thing but prints it
|
||||
"""
|
||||
|
||||
def ruler(arg=None, sep="_", print_=False, width=60):
|
||||
if arg:
|
||||
result = "[ {} ]".format(str(arg)).center(width, sep) + "\n"
|
||||
else:
|
||||
result = "".center(width, sep) + "\n"
|
||||
if print_:
|
||||
print(result)
|
||||
else:
|
||||
return result
|
||||
|
||||
def head(arg=None, sep="_", width=60): ruler(arg, sep, True, width)
|
||||
|
||||
@ -1,11 +0,0 @@
|
||||
from betools import CmdLine, visitDir
|
||||
|
||||
@CmdLine("t", "test")
|
||||
def test(arg="default1", arg2="default2"):
|
||||
"""
|
||||
Testing CmdLine
|
||||
"""
|
||||
print("test", arg, arg2)
|
||||
|
||||
|
||||
if __name__ == '__main__': CmdLine.run()
|
||||
@ -1,17 +0,0 @@
|
||||
#! py -3
|
||||
"""
|
||||
Visits a directory and automatically returns to original
|
||||
directory when you're done.
|
||||
"""
|
||||
from contextlib import contextmanager
|
||||
import os
|
||||
|
||||
@contextmanager
|
||||
def visitDir(d):
|
||||
d = str(d)
|
||||
old = os.getcwd()
|
||||
os.chdir(d)
|
||||
yield d
|
||||
os.chdir(old)
|
||||
|
||||
|
||||
@ -1,258 +0,0 @@
|
||||
//: concurrency/SynchronizationComparisons.java
|
||||
// Comparing the performance of explicit Locks
|
||||
// and Atomics versus the synchronized keyword.
|
||||
import java.util.concurrent.*;
|
||||
import java.util.concurrent.atomic.*;
|
||||
import java.util.concurrent.locks.*;
|
||||
import java.util.*;
|
||||
import static net.mindview.util.Print.*;
|
||||
|
||||
abstract class Accumulator {
|
||||
public static long cycles = 50000L;
|
||||
// Number of Modifiers and Readers during each test:
|
||||
private static final int N = 4;
|
||||
public static ExecutorService exec =
|
||||
Executors.newFixedThreadPool(N*2);
|
||||
private static CyclicBarrier barrier =
|
||||
new CyclicBarrier(N*2 + 1);
|
||||
protected volatile int index = 0;
|
||||
protected volatile long value = 0;
|
||||
protected long duration = 0;
|
||||
protected String id = "error";
|
||||
protected final static int SIZE = 100000;
|
||||
protected static int[] preLoaded = new int[SIZE];
|
||||
static {
|
||||
// Load the array of random numbers:
|
||||
Random rand = new Random(47);
|
||||
for(int i = 0; i < SIZE; i++)
|
||||
preLoaded[i] = rand.nextInt();
|
||||
}
|
||||
public abstract void accumulate();
|
||||
public abstract long read();
|
||||
private class Modifier implements Runnable {
|
||||
public void run() {
|
||||
for(long i = 0; i < cycles; i++)
|
||||
accumulate();
|
||||
try {
|
||||
barrier.await();
|
||||
} catch(Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
private class Reader implements Runnable {
|
||||
private volatile long value;
|
||||
public void run() {
|
||||
for(long i = 0; i < cycles; i++)
|
||||
value = read();
|
||||
try {
|
||||
barrier.await();
|
||||
} catch(Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
public void timedTest() {
|
||||
long start = System.nanoTime();
|
||||
for(int i = 0; i < N; i++) {
|
||||
exec.execute(new Modifier());
|
||||
exec.execute(new Reader());
|
||||
}
|
||||
try {
|
||||
barrier.await();
|
||||
} catch(Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
duration = System.nanoTime() - start;
|
||||
printf("%-13s: %13d\n", id, duration);
|
||||
}
|
||||
public static void
|
||||
report(Accumulator acc1, Accumulator acc2) {
|
||||
printf("%-22s: %.2f\n", acc1.id + "/" + acc2.id,
|
||||
(double)acc1.duration/(double)acc2.duration);
|
||||
}
|
||||
}
|
||||
|
||||
class BaseLine extends Accumulator {
|
||||
{ id = "BaseLine"; }
|
||||
public void accumulate() {
|
||||
if(index >= SIZE - 1) index = 0;
|
||||
value += preLoaded[index++];
|
||||
}
|
||||
public long read() { return value; }
|
||||
}
|
||||
|
||||
class SynchronizedTest extends Accumulator {
|
||||
{ id = "synchronized"; }
|
||||
public synchronized void accumulate() {
|
||||
if(index >= SIZE - 1) index = 0;
|
||||
value += preLoaded[index++];
|
||||
}
|
||||
public synchronized long read() {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
class LockTest extends Accumulator {
|
||||
{ id = "Lock"; }
|
||||
private Lock lock = new ReentrantLock();
|
||||
public void accumulate() {
|
||||
lock.lock();
|
||||
try {
|
||||
if(index >= SIZE - 1) index = 0;
|
||||
value += preLoaded[index++];
|
||||
} finally {
|
||||
lock.unlock();
|
||||
}
|
||||
}
|
||||
public long read() {
|
||||
lock.lock();
|
||||
try {
|
||||
return value;
|
||||
} finally {
|
||||
lock.unlock();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class AtomicTest extends Accumulator {
|
||||
{ id = "Atomic"; }
|
||||
private AtomicInteger index = new AtomicInteger(0);
|
||||
private AtomicLong value = new AtomicLong(0);
|
||||
public void accumulate() {
|
||||
// Oops! Relying on more than one Atomic at
|
||||
// a time doesn't work. But it still gives us
|
||||
// a performance indicator:
|
||||
int i = index.getAndIncrement();
|
||||
if(++i >= SIZE - 1) {
|
||||
i = 0;
|
||||
index.set(i);
|
||||
}
|
||||
value.getAndAdd(preLoaded[i]);
|
||||
}
|
||||
public long read() { return value.get(); }
|
||||
}
|
||||
|
||||
public class SynchronizationComparisons {
|
||||
static BaseLine baseLine = new BaseLine();
|
||||
static SynchronizedTest synch = new SynchronizedTest();
|
||||
static LockTest lock = new LockTest();
|
||||
static AtomicTest atomic = new AtomicTest();
|
||||
static void test() {
|
||||
print("============================");
|
||||
printf("%-12s : %13d\n", "Cycles", Accumulator.cycles);
|
||||
baseLine.timedTest();
|
||||
synch.timedTest();
|
||||
lock.timedTest();
|
||||
atomic.timedTest();
|
||||
Accumulator.report(synch, baseLine);
|
||||
Accumulator.report(lock, baseLine);
|
||||
Accumulator.report(atomic, baseLine);
|
||||
Accumulator.report(synch, lock);
|
||||
Accumulator.report(synch, atomic);
|
||||
Accumulator.report(lock, atomic);
|
||||
}
|
||||
public static void main(String[] args) {
|
||||
int iterations = 5; // Default
|
||||
if(args.length > 0) // Optionally change iterations
|
||||
iterations = new Integer(args[0]);
|
||||
// The first time fills the thread pool:
|
||||
print("Warmup");
|
||||
baseLine.timedTest();
|
||||
// Now the initial test doesn't include the cost
|
||||
// of starting the threads for the first time.
|
||||
// Produce multiple data points:
|
||||
for(int i = 0; i < iterations; i++) {
|
||||
test();
|
||||
Accumulator.cycles *= 2;
|
||||
}
|
||||
Accumulator.exec.shutdown();
|
||||
}
|
||||
} /* Output: (Sample)
|
||||
Warmup
|
||||
BaseLine : 34237033
|
||||
============================
|
||||
Cycles : 50000
|
||||
BaseLine : 20966632
|
||||
synchronized : 24326555
|
||||
Lock : 53669950
|
||||
Atomic : 30552487
|
||||
synchronized/BaseLine : 1.16
|
||||
Lock/BaseLine : 2.56
|
||||
Atomic/BaseLine : 1.46
|
||||
synchronized/Lock : 0.45
|
||||
synchronized/Atomic : 0.79
|
||||
Lock/Atomic : 1.76
|
||||
============================
|
||||
Cycles : 100000
|
||||
BaseLine : 41512818
|
||||
synchronized : 43843003
|
||||
Lock : 87430386
|
||||
Atomic : 51892350
|
||||
synchronized/BaseLine : 1.06
|
||||
Lock/BaseLine : 2.11
|
||||
Atomic/BaseLine : 1.25
|
||||
synchronized/Lock : 0.50
|
||||
synchronized/Atomic : 0.84
|
||||
Lock/Atomic : 1.68
|
||||
============================
|
||||
Cycles : 200000
|
||||
BaseLine : 80176670
|
||||
synchronized : 5455046661
|
||||
Lock : 177686829
|
||||
Atomic : 101789194
|
||||
synchronized/BaseLine : 68.04
|
||||
Lock/BaseLine : 2.22
|
||||
Atomic/BaseLine : 1.27
|
||||
synchronized/Lock : 30.70
|
||||
synchronized/Atomic : 53.59
|
||||
Lock/Atomic : 1.75
|
||||
============================
|
||||
Cycles : 400000
|
||||
BaseLine : 160383513
|
||||
synchronized : 780052493
|
||||
Lock : 362187652
|
||||
Atomic : 202030984
|
||||
synchronized/BaseLine : 4.86
|
||||
Lock/BaseLine : 2.26
|
||||
Atomic/BaseLine : 1.26
|
||||
synchronized/Lock : 2.15
|
||||
synchronized/Atomic : 3.86
|
||||
Lock/Atomic : 1.79
|
||||
============================
|
||||
Cycles : 800000
|
||||
BaseLine : 322064955
|
||||
synchronized : 336155014
|
||||
Lock : 704615531
|
||||
Atomic : 393231542
|
||||
synchronized/BaseLine : 1.04
|
||||
Lock/BaseLine : 2.19
|
||||
Atomic/BaseLine : 1.22
|
||||
synchronized/Lock : 0.47
|
||||
synchronized/Atomic : 0.85
|
||||
Lock/Atomic : 1.79
|
||||
============================
|
||||
Cycles : 1600000
|
||||
BaseLine : 650004120
|
||||
synchronized : 52235762925
|
||||
Lock : 1419602771
|
||||
Atomic : 796950171
|
||||
synchronized/BaseLine : 80.36
|
||||
Lock/BaseLine : 2.18
|
||||
Atomic/BaseLine : 1.23
|
||||
synchronized/Lock : 36.80
|
||||
synchronized/Atomic : 65.54
|
||||
Lock/Atomic : 1.78
|
||||
============================
|
||||
Cycles : 3200000
|
||||
BaseLine : 1285664519
|
||||
synchronized : 96336767661
|
||||
Lock : 2846988654
|
||||
Atomic : 1590545726
|
||||
synchronized/BaseLine : 74.93
|
||||
Lock/BaseLine : 2.21
|
||||
Atomic/BaseLine : 1.24
|
||||
synchronized/Lock : 33.84
|
||||
synchronized/Atomic : 60.57
|
||||
Lock/Atomic : 1.79
|
||||
*///:~
|
||||
@ -1,106 +0,0 @@
|
||||
//: io/StoreCADState.java
|
||||
// Saving the state of a pretend CAD system.
|
||||
import java.io.*;
|
||||
import java.util.*;
|
||||
|
||||
abstract class Shape implements Serializable {
|
||||
public static final int RED = 1, BLUE = 2, GREEN = 3;
|
||||
private int xPos, yPos, dimension;
|
||||
private static Random rand = new Random(47);
|
||||
private static int counter = 0;
|
||||
public abstract void setColor(int newColor);
|
||||
public abstract int getColor();
|
||||
public Shape(int xVal, int yVal, int dim) {
|
||||
xPos = xVal;
|
||||
yPos = yVal;
|
||||
dimension = dim;
|
||||
}
|
||||
public String toString() {
|
||||
return getClass() +
|
||||
"color[" + getColor() + "] xPos[" + xPos +
|
||||
"] yPos[" + yPos + "] dim[" + dimension + "]\n";
|
||||
}
|
||||
public static Shape randomFactory() {
|
||||
int xVal = rand.nextInt(100);
|
||||
int yVal = rand.nextInt(100);
|
||||
int dim = rand.nextInt(100);
|
||||
switch(counter++ % 3) {
|
||||
default:
|
||||
case 0: return new Circle(xVal, yVal, dim);
|
||||
case 1: return new Square(xVal, yVal, dim);
|
||||
case 2: return new Line(xVal, yVal, dim);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Circle extends Shape {
|
||||
private static int color = RED;
|
||||
public Circle(int xVal, int yVal, int dim) {
|
||||
super(xVal, yVal, dim);
|
||||
}
|
||||
public void setColor(int newColor) { color = newColor; }
|
||||
public int getColor() { return color; }
|
||||
}
|
||||
|
||||
class Square extends Shape {
|
||||
private static int color;
|
||||
public Square(int xVal, int yVal, int dim) {
|
||||
super(xVal, yVal, dim);
|
||||
color = RED;
|
||||
}
|
||||
public void setColor(int newColor) { color = newColor; }
|
||||
public int getColor() { return color; }
|
||||
}
|
||||
|
||||
class Line extends Shape {
|
||||
private static int color = RED;
|
||||
public static void
|
||||
serializeStaticState(ObjectOutputStream os)
|
||||
throws IOException { os.writeInt(color); }
|
||||
public static void
|
||||
deserializeStaticState(ObjectInputStream os)
|
||||
throws IOException { color = os.readInt(); }
|
||||
public Line(int xVal, int yVal, int dim) {
|
||||
super(xVal, yVal, dim);
|
||||
}
|
||||
public void setColor(int newColor) { color = newColor; }
|
||||
public int getColor() { return color; }
|
||||
}
|
||||
|
||||
public class StoreCADState {
|
||||
public static void main(String[] args) throws Exception {
|
||||
List<Class<? extends Shape>> shapeTypes =
|
||||
new ArrayList<Class<? extends Shape>>();
|
||||
// Add references to the class objects:
|
||||
shapeTypes.add(Circle.class);
|
||||
shapeTypes.add(Square.class);
|
||||
shapeTypes.add(Line.class);
|
||||
List<Shape> shapes = new ArrayList<Shape>();
|
||||
// Make some shapes:
|
||||
for(int i = 0; i < 10; i++)
|
||||
shapes.add(Shape.randomFactory());
|
||||
// Set all the static colors to GREEN:
|
||||
for(int i = 0; i < 10; i++)
|
||||
((Shape)shapes.get(i)).setColor(Shape.GREEN);
|
||||
// Save the state vector:
|
||||
ObjectOutputStream out = new ObjectOutputStream(
|
||||
new FileOutputStream("CADState.out"));
|
||||
out.writeObject(shapeTypes);
|
||||
Line.serializeStaticState(out);
|
||||
out.writeObject(shapes);
|
||||
// Display the shapes:
|
||||
System.out.println(shapes);
|
||||
}
|
||||
} /* Output:
|
||||
[class Circlecolor[3] xPos[58] yPos[55] dim[93]
|
||||
, class Squarecolor[3] xPos[61] yPos[61] dim[29]
|
||||
, class Linecolor[3] xPos[68] yPos[0] dim[22]
|
||||
, class Circlecolor[3] xPos[7] yPos[88] dim[28]
|
||||
, class Squarecolor[3] xPos[51] yPos[89] dim[9]
|
||||
, class Linecolor[3] xPos[78] yPos[98] dim[61]
|
||||
, class Circlecolor[3] xPos[20] yPos[58] dim[16]
|
||||
, class Squarecolor[3] xPos[40] yPos[11] dim[22]
|
||||
, class Linecolor[3] xPos[4] yPos[83] dim[6]
|
||||
, class Circlecolor[3] xPos[75] yPos[10] dim[42]
|
||||
]
|
||||
*///:~
|
||||
@ -1,66 +0,0 @@
|
||||
//: net/mindview/atunit/AtUnitRemover.java
|
||||
// Displays @Unit annotations in compiled class files. If
|
||||
// first argument is "-r", @Unit annotations are removed.
|
||||
// {ThrowsException} Some kind of bug here...
|
||||
// {Args: ..}
|
||||
// {Requires: javassist.bytecode.ClassFile;
|
||||
// You must install the Javassist library from
|
||||
// www.javassist.org }
|
||||
package net.mindview.atunit;
|
||||
import javassist.*;
|
||||
import javassist.bytecode.*;
|
||||
import javassist.bytecode.annotation.*;
|
||||
import java.io.*;
|
||||
import net.mindview.util.*;
|
||||
import static net.mindview.util.Print.*;
|
||||
|
||||
public class AtUnitRemover
|
||||
implements ProcessFiles.Strategy {
|
||||
private static boolean remove = false;
|
||||
public static void main(String[] args) throws Exception {
|
||||
if(args.length > 0 && args[0].equals("-r")) {
|
||||
remove = true;
|
||||
String[] nargs = new String[args.length - 1];
|
||||
System.arraycopy(args, 1, nargs, 0, nargs.length);
|
||||
args = nargs;
|
||||
}
|
||||
new ProcessFiles(
|
||||
new AtUnitRemover(), "class").start(args);
|
||||
}
|
||||
@Override
|
||||
public void process(File cFile) {
|
||||
boolean modified = false;
|
||||
try {
|
||||
String cName = ClassNameFinder.thisClass(
|
||||
BinaryFile.read(cFile));
|
||||
if(!cName.contains("."))
|
||||
return; // Ignore unpackaged classes
|
||||
ClassPool cPool = ClassPool.getDefault();
|
||||
CtClass ctClass = cPool.get(cName);
|
||||
for(CtMethod method : ctClass.getDeclaredMethods()) {
|
||||
MethodInfo mi = method.getMethodInfo();
|
||||
AnnotationsAttribute attr = (AnnotationsAttribute)
|
||||
mi.getAttribute(AnnotationsAttribute.visibleTag);
|
||||
if(attr == null) continue;
|
||||
for(Annotation ann : attr.getAnnotations()) {
|
||||
if(ann.getTypeName()
|
||||
.startsWith("net.mindview.atunit")) {
|
||||
print(ctClass.getName() + " Method: "
|
||||
+ mi.getName() + " " + ann);
|
||||
if(remove) {
|
||||
ctClass.removeMethod(method);
|
||||
modified = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Fields are not removed in this version (see text).
|
||||
if(modified)
|
||||
ctClass.toBytecode(new DataOutputStream(
|
||||
new FileOutputStream(cFile)));
|
||||
ctClass.detach();
|
||||
} catch(Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
} ///:~
|
||||
@ -1,82 +0,0 @@
|
||||
//: net/mindview/util/TextFile.java
|
||||
// Static functions for reading and writing text files as
|
||||
// a single string, and treating a file as an ArrayList.
|
||||
package net.mindview.util;
|
||||
import java.io.*;
|
||||
import java.util.*;
|
||||
|
||||
public class TextFile extends ArrayList<String> {
|
||||
// Read a file as a single string:
|
||||
public static String read(String fileName) {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
try {
|
||||
BufferedReader in= new BufferedReader(new FileReader(
|
||||
new File(fileName).getAbsoluteFile()));
|
||||
try {
|
||||
String s;
|
||||
while((s = in.readLine()) != null) {
|
||||
sb.append(s);
|
||||
sb.append("\n");
|
||||
}
|
||||
} finally {
|
||||
in.close();
|
||||
}
|
||||
} catch(IOException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
// Write a single file in one method call:
|
||||
public static void write(String fileName, String text) {
|
||||
try {
|
||||
PrintWriter out = new PrintWriter(
|
||||
new File(fileName).getAbsoluteFile());
|
||||
try {
|
||||
out.print(text);
|
||||
} finally {
|
||||
out.close();
|
||||
}
|
||||
} catch(IOException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
// Read a file, split by any regular expression:
|
||||
public TextFile(String fileName, String splitter) {
|
||||
super(Arrays.asList(read(fileName).split(splitter)));
|
||||
// Regular expression split() often leaves an empty
|
||||
// String at the first position:
|
||||
if(get(0).equals("")) remove(0);
|
||||
}
|
||||
// Normally read by lines:
|
||||
public TextFile(String fileName) {
|
||||
this(fileName, "\n");
|
||||
}
|
||||
public void write(String fileName) {
|
||||
try {
|
||||
PrintWriter out = new PrintWriter(
|
||||
new File(fileName).getAbsoluteFile());
|
||||
try {
|
||||
for(String item : this)
|
||||
out.println(item);
|
||||
} finally {
|
||||
out.close();
|
||||
}
|
||||
} catch(IOException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
// Simple test:
|
||||
public static void main(String[] args) {
|
||||
String file = read("TextFile.java");
|
||||
write("test.txt", file);
|
||||
TextFile text = new TextFile("test.txt");
|
||||
text.write("test2.txt");
|
||||
// Break into unique sorted list of words:
|
||||
TreeSet<String> words = new TreeSet<String>(
|
||||
new TextFile("TextFile.java", "\\W+"));
|
||||
// Display the capitalized words:
|
||||
System.out.println(words.headSet("a"));
|
||||
}
|
||||
} /* Output:
|
||||
[0, ArrayList, Arrays, Break, BufferedReader, BufferedWriter, Clean, Display, File, FileReader, FileWriter, IOException, Normally, Output, PrintWriter, Read, Regular, RuntimeException, Simple, Static, String, StringBuilder, System, TextFile, Tools, TreeSet, W, Write]
|
||||
*///:~
|
||||
@ -1,82 +0,0 @@
|
||||
//: net/mindview/util/TextFile.java
|
||||
// Static functions for reading and writing text files as
|
||||
// a single string, and treating a file as an ArrayList.
|
||||
package net.mindview.util;
|
||||
import java.io.*;
|
||||
import java.util.*;
|
||||
|
||||
public class TextFile extends ArrayList<String> {
|
||||
// Read a file as a single string:
|
||||
public static String read(String fileName) {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
try {
|
||||
BufferedReader in= new BufferedReader(new FileReader(
|
||||
new File(fileName).getAbsoluteFile()));
|
||||
try {
|
||||
String s;
|
||||
while((s = in.readLine()) != null) {
|
||||
sb.append(s);
|
||||
sb.append("\n");
|
||||
}
|
||||
} finally {
|
||||
in.close();
|
||||
}
|
||||
} catch(IOException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
// Write a single file in one method call:
|
||||
public static void write(String fileName, String text) {
|
||||
try {
|
||||
PrintWriter out = new PrintWriter(
|
||||
new File(fileName).getAbsoluteFile());
|
||||
try {
|
||||
out.print(text);
|
||||
} finally {
|
||||
out.close();
|
||||
}
|
||||
} catch(IOException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
// Read a file, split by any regular expression:
|
||||
public TextFile(String fileName, String splitter) {
|
||||
super(Arrays.asList(read(fileName).split(splitter)));
|
||||
// Regular expression split() often leaves an empty
|
||||
// String at the first position:
|
||||
if(get(0).equals("")) remove(0);
|
||||
}
|
||||
// Normally read by lines:
|
||||
public TextFile(String fileName) {
|
||||
this(fileName, "\n");
|
||||
}
|
||||
public void write(String fileName) {
|
||||
try {
|
||||
PrintWriter out = new PrintWriter(
|
||||
new File(fileName).getAbsoluteFile());
|
||||
try {
|
||||
for(String item : this)
|
||||
out.println(item);
|
||||
} finally {
|
||||
out.close();
|
||||
}
|
||||
} catch(IOException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
// Simple test:
|
||||
public static void main(String[] args) {
|
||||
String file = read("TextFile.java");
|
||||
write("test.txt", file);
|
||||
TextFile text = new TextFile("test.txt");
|
||||
text.write("test2.txt");
|
||||
// Break into unique sorted list of words:
|
||||
TreeSet<String> words = new TreeSet<String>(
|
||||
new TextFile("TextFile.java", "\\W+"));
|
||||
// Display the capitalized words:
|
||||
System.out.println(words.headSet("a"));
|
||||
}
|
||||
} /* Output:
|
||||
[0, ArrayList, Arrays, Break, BufferedReader, BufferedWriter, Clean, Display, File, FileReader, FileWriter, IOException, Normally, Output, PrintWriter, Read, Regular, RuntimeException, Simple, Static, String, StringBuilder, System, TextFile, Tools, TreeSet, W, Write]
|
||||
*///:~
|
||||
@ -1,14 +0,0 @@
|
||||
//: patterns/trash/FillableArrayList.java
|
||||
// Adapter that makes an ArrayList Fillable.
|
||||
package patterns.trash;
|
||||
import java.util.*;
|
||||
|
||||
public class FillableArrayList
|
||||
implements Fillable {
|
||||
private ArrayList v;
|
||||
public FillableArrayList(ArrayList vv) { v = vv; }
|
||||
@Override
|
||||
public void addTrash(Trash t) {
|
||||
v.add(t);
|
||||
}
|
||||
} ///:~
|
||||
Loading…
x
Reference in New Issue
Block a user