🚀 go-pugleaf

Er bestaat in de Java 1.3 SDK niet meteen het equivalent van de C++
for_each om over container te lopen, maar het is redelijk simpel
om te simuleren via een interface.

Het ziet er mij - op een bepaalde manier - properder uit dan de
klassieke manier waarbij eerst een iterator wordt gemaakt, en
daarna over de container te lopen. Maar met een simpele timing
is het zichtbaar dat die "schoonheid" ook met een klein
performance samengaat.

Bij het testen op i386 machines (M$ Win2000 en GNU/Linux), komt
de "simpele" methode er meestal 5% tot 10% sneller uit. Soms
is het "function object" iets sneller, maar over het algemeen
gezien verschillen de twee niet al te veel.

Maar als ik dezelfde code op een HP/UX 11.00 draai, met laatste
Java 1.3.1, gaat de function object methode een factor 2 tot 4
sneller. De snelheidswinst treedt vooral op bij langere lijsten,
het lijkt dat de overhead van het creeeren van het function object
met korte lijsten verhoudingsgewijs veel meer tijd inneemt. Bij
lijsten met minder dan 1000 elementen wint de klassieke manier
met gemak.

Iemand daar een zinnige uitleg voor? Of nog mensen die wat willen
experimenteren op niet Intel-achtige machines?


==== CollectionExtender.java ====

import java.util.Iterator;
import java.util.Collection;
import java.util.LinkedList;

public class CollectionExtender {

	public interface Function {
		void eat(Object object);
	}

	public static void forEach(Collection collection, Function function) {
		Iterator it = collection.iterator();
		while (it.hasNext()) {
			function.eat(it.next());
		}
	}

	private static class Sum implements Function {
		public void eat(Object object) {
			this.sum += ( (Double) object ).doubleValue();
		}
		public double getValue() {
			return this.sum;
		}
		private double sum = 0;
	}

	private static class Average implements Function {
		public void eat(Object object) {
			this.sum += ( (Double) object ).doubleValue();
			++this.count;
		}
		public double getValue() {
			return sum / count;
		}
		private double sum = 0;
		private long count = 0;
	}

	public static void main(String args[]) {
		LinkedList list = new LinkedList();
		for (int i = 0 ; i < 200000 ; ++i) {
			list.add(new Double(3));
		}

		double start = 0;

		start = System.currentTimeMillis();
		double sum = 0;
		for (int i = 0 ; i < 10 ; ++i) {
			sum = 0;
			Iterator it = list.iterator();
			while (it.hasNext()) {
				sum += ( (Double) it.next()).doubleValue();
			}
		}
		double sum_duration_iter = System.currentTimeMillis() - start;

		start = System.currentTimeMillis();
		Sum sumFunction = null;
		for (int i = 0 ; i < 10 ; ++i) {
			sumFunction = new Sum();
			forEach(list, sumFunction);
		}
		double sum_duration_func = System.currentTimeMillis() - start;

		start = System.currentTimeMillis();
		Average average = null;
		for (int i = 0 ; i < 10 ; ++i) {
			average = new Average();
			forEach(list, average);
		}
		double avg_duration_func = System.currentTimeMillis() - start;

		start = System.currentTimeMillis();
		double avg = 0;
		for (int i = 0 ; i < 10 ; ++i) {
			double avg_sum = 0;
			long count = 0;
			Iterator it = list.iterator();
			while (it.hasNext()) {
				avg_sum += ( (Double) it.next()).doubleValue();
				++count;
			}
			avg = avg_sum / count;
		}
		double avg_duration_iter = System.currentTimeMillis() - start;

		System.out.println("sum_func = " + sumFunction.getValue());
		System.out.println("sum_iter = " + sum);
		System.out.println("average_func = " + average.getValue());
		System.out.println("average_iter = " + avg);
		
		System.out.println("duration_func = " + sum_duration_func);
		System.out.println("duration_iter = " + sum_duration_iter);
		System.out.println("avg_duration_func = " + avg_duration_func);
		System.out.println("avg_duration_iter = " + avg_duration_iter);

	}

}

-- 
fingerprint = A3C4 DE50 712D 4FA8 C564  4D96 5E06 C9CC ECFA 19C5
Open source advocate