[読書]ケント・ベック 実装パターン

Kent Beck の実装パターンを読んだ。
日常的にコードを書く人ではない、趣味の園芸な自分が読んでも楽しめる。

一通り読んだものの咀嚼出来ていないところがあるので、時間を見つけて査読したいな。

ちょっと前に、Junitのソースコードを眺めていたんだけど、この本読んでる最中に、
「ああ、ここの記述はあそこのソースでもやってたなぁ」と思いだした。
もう一度、Junitちゃんと読んでみようかなぁ。

コレクションAPIのパフォーマンス比較をするために、測定用フレームワークを作っていて付録Aで
そのコードを公開している、コード自体はとても小さいシンプルなものだけど、本書の中のパターン
が使われている。

後でWebで見たかったので写経してみた。
コメントいれてる。変なところがあったら御免なさい。

このListSerchクラスのserchメソッドの実行時間を計測すると
search 25.30 77.81 551.10 と結果出力される。
要素数が増加すると実行時間が増えている。

+ expand sourceview plainprint?

1. import java.util.ArrayList;  
2. import java.util.List;  
3.   
4. public class ListSerch {  
5. private List<Integer> numbers;  
6. private int probe;  
7.   
8. public ListSerch(int size){  
9. numbers = new ArrayList<Integer>();  
10. for (int i = 0; i < size; i++) {  
11. numbers.add(i);  
12. probe = size / 2;  
13. }  
14. }  
15. //ArrayListの真ん中を取得させる。  
16. public void search(){  
17. numbers.contains(probe);  
18. }  
19. }  

import java.util.ArrayList;
import java.util.List;

public class ListSerch {
private List<Integer> numbers;
private int probe;

public ListSerch(int size){
numbers = new ArrayList<Integer>();
for (int i = 0; i < size; i++) {
numbers.add(i);
probe = size / 2;
}
}
//ArrayListの真ん中を取得させる。
public void search(){
numbers.contains(probe);
}
}

ドライバークラスは以下。
テストしたいクラスに含まれるメソッドの配列を引数にしてMethodsTimerインスタンス化。
report()メソッドを実行する。
結果はコンソールに
メソッド名 1回実行での時間 10回実行での合計時間 100回実行での合計時間 ・・・合計が1秒こえるまでやる。

+ expand sourceview plainprint?

1. public class TestDriver {  
2.   
3.   public static void main(String[] args) throws Exception{  
4.     MethodsTimer tester = new MethodsTimer(ListSerch.class.getDeclaredMethods());  
5.     tester.report();  
6.   }  
7. }  

public class TestDriver {

  public static void main(String[] args) throws Exception{
    MethodsTimer tester = new MethodsTimer(ListSerch.class.getDeclaredMethods());
    tester.report();
  }
}

+ expand sourceview plainprint?

1. import java.lang.reflect.Method;  
2.   
3. public class MethodsTimer {  
4. public final Method[] methods;  
5. private static final int MAXIMUM_SIZE = 100;  
6. public static final int ONE_SECOND = 1000000000;  
7.   
8. public MethodsTimer(Method[] methods){  
9.  this.methods = methods;  
10.  }  
11.   
12. public void report() throws Exception{  
13.  for(Method each : methods){  
14.      System.out.print(String.format("%.2f\t", r.getMethodTime()));  
15.      for (int size = 1; size <= MAXIMUM_SIZE; size *=10)   
16.      {                 
17.       MethodTimer r = new MethodTimer(size, each);  
18.       r.run();  
19.       System.out.print(r.getMethodTime() + "\t");  
20.       }  
21.      System.out.println();           
22.      }  
23.  }  
24. }      

import java.lang.reflect.Method;

public class MethodsTimer {
public final Method[] methods;
private static final int MAXIMUM_SIZE = 100;
public static final int ONE_SECOND = 1000000000;

public MethodsTimer(Method[] methods){
 this.methods = methods;
 }

public void report() throws Exception{
 for(Method each : methods){
     System.out.print(String.format("%.2f\t", r.getMethodTime()));
     for (int size = 1; size <= MAXIMUM_SIZE; size *=10) 
     {               
      MethodTimer r = new MethodTimer(size, each);
      r.run();
      System.out.print(r.getMethodTime() + "\t");
      }
     System.out.println();         
     }
 }
}    

+ expand sourceview plainprint?

1. import java.lang.reflect.Constructor;  
2. import java.lang.reflect.Method;  
3.   
4. public class MethodTimer {  
5.  private final int size;  
6.  private final Method method;  
7.  private Object instance;  
8.  private long totalTime;  
9.  private int iterations;  
10.  private long overhead;  
11.   
12.  public MethodTimer(int size, Method method) throws Exception{  
13.   this.size=size;  
14.   this.method=method;  
15.   instance = createInstance();  
16.  }  
17.    
18.  public MethodTimer(int iterations) throws Exception{  
19.   this(0,MethodTimer.Overhead.class.getMethod("nothing", new Class[0]));  
20.   this.iterations = iterations;  
21.  }  
22.    
23.  private static MethodTimer overheadTimer(int iterations) throws Exception{  
24.  return new MethodTimer(iterations);  
25.  }  
26.   
27.     private Object createInstance() throws Exception {  
28.         Constructor<?> constructor = method.getDeclaringClass().getConstructor(  
29.                 new Class[] { int.class });  
30.         return constructor.newInstance(new Object[] { size });  
31.     }  
32.   
33.  double getMethodTime(){  
34.   return (double)(totalTime - overhead) / (double)iterations;  
35.  }  
36.   
37.   
38.     void run() throws Exception {  
39.         iterations = 1;  
40.         while (true) {  
41.             totalTime = computeTotalTime();  
42.             if (totalTime > MethodsTimer.ONE_SECOND)  
43.                 break;  
44.             iterations *= 2;  
45.         }  
46.         overhead = overheadTimer(iterations).computeTotalTime();  
47.     }  
48.   
49.   
50.   
51.     private long computeTotalTime() throws Exception {  
52.         long start = System.nanoTime();  
53.         for (int i = 0; i < iterations; i++) {  
54.             method.invoke(instance, new Object[0]);  
55.         }  
56.         return System.nanoTime() - start;  
57.     }  
58.       
59.     public static class Overhead {  
60.         public Overhead(int size) { }  
61.         public void nothing() { }  
62.     }  
63.   
64. }  

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class MethodTimer {
 private final int size;
 private final Method method;
 private Object instance;
 private long totalTime;
 private int iterations;
 private long overhead;

 public MethodTimer(int size, Method method) throws Exception{
  this.size=size;
  this.method=method;
  instance = createInstance();
 }
 
 public MethodTimer(int iterations) throws Exception{
  this(0,MethodTimer.Overhead.class.getMethod("nothing", new Class[0]));
  this.iterations = iterations;
 }
 
 private static MethodTimer overheadTimer(int iterations) throws Exception{
 return new MethodTimer(iterations);
 }

    private Object createInstance() throws Exception {
        Constructor<?> constructor = method.getDeclaringClass().getConstructor(
                new Class[] { int.class });
        return constructor.newInstance(new Object[] { size });
    }

 double getMethodTime(){
  return (double)(totalTime - overhead) / (double)iterations;
 }


    void run() throws Exception {
        iterations = 1;
        while (true) {
            totalTime = computeTotalTime();
            if (totalTime > MethodsTimer.ONE_SECOND)
                break;
            iterations *= 2;
        }
        overhead = overheadTimer(iterations).computeTotalTime();
    }



    private long computeTotalTime() throws Exception {
        long start = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            method.invoke(instance, new Object[0]);
        }
        return System.nanoTime() - start;
    }
    
    public static class Overhead {
        public Overhead(int size) { }
        public void nothing() { }
    }

}