Schnellstmögliches Lesen/Schreiben auf HDD ?

[Guest]

Ahoi!
Ich versuche gerade so fix wie möglich ein riesiges double-Array auf die HDD zu schreiben und es von dort wieder zu rekonstruieren.

Als Kandidaten fielen mir hierfür ein: DataOutputStream und ObjectOutputStream (bzw. jeweils *Input*).
Folgender Mini-Benchmark zeigt, dass ObjectOutputStream wesentlich schneller ist. Meine Ergebnisse:

Streaming out: 10 x 1000000 doubles
dos-time : 24422
oos-time : 1203
Streaming in: 10 x 1000000 doubles
dis-time : 16344
ois-time : 1063

Allerdings schafft eine zum Vergleich in PureBasic gecodete und in Maschinencode übersetzte Version für denselben Zweck mit einiges Tricks Laufzeiten von um die 700 (streaming out) und nur 120 (streaming in), also nochmals stark beschleunigt. Auch habe ich bereits die PureBasic-gecodeten Routinen in eine DLL gepackt und dann per JNI von Java aus aufgerufen. Auch diese Variante ist immernoch (wenn auch nur noch geringfügig) schneller.

Hat also noch jemand eine Idee, wie das mit Java-eigenen Mitteln zu beschleunigen geht ? Irgendwie direkt von der Datei in den Speicher streamen, oder so ?

Der Speedcontest ist eröffnet ;-)

Danke + Guten Morgen,

kopfsalat

Hier meine Testklassen:

Die Datenhaltungs-Klasse

package serializableSpeed;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.Serializable;

public class MyData implements Serializable {
	private static final long serialVersionUID = -2319633440412883951L;
	
	private double[] data;

	public void initializeByRandom(int size) {
		data = new double[size];
		
		for (int i=0; i<size; i++) {
			data[i] = Math.sin(i * 1.0 / 44100); 
		}
	}
	
	public void saveManuallyDataOutputStream(File file) throws IOException {
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream ds = new DataOutputStream(fos);
				
		ds.writeInt(data.length);
		for (int i=0; i<data.length; i++) {
			ds.writeDouble(data[i]);
		}

		ds.flush();
		ds.close();
		fos.close();
	}
	
	public void loadManuallyDataInputStream(File file) throws IOException {
		FileInputStream fis = new FileInputStream(file);
		DataInputStream ds = new DataInputStream(fis);
				
		data = new double[ds.readInt()];
		for (int i=0; i<data.length; i++) {
			data[i] = ds.readDouble();
		}

		ds.close();
		fis.close();
	}
}

Die Datei, um den Benchmark-Test zu starten

package serializableSpeed;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class RunSpeedTest {

	public static void streamTest() throws IOException, ClassNotFoundException {
		int size = 1000000;
		int count = 10;
		MyData dat = new MyData();
		
		dat.initializeByRandom(size);

		//
		// SAVING
		//
		System.out.println("Streaming out: " + count + " x " + size + " doubles");

		long time = System.currentTimeMillis();
		File f;

		// saving using a DataOutputStream
		for (int i=0; i<count; i++) {
			f = new File("dos_" + i + ".dat");
			dat.saveManuallyDataOutputStream(f);
		}
		time = System.currentTimeMillis() - time;
		System.out.println("dos-time : " + time); System.out.flush();
				
		// saving using an ObjectOutputStream
		time = System.currentTimeMillis();
		for (int i = 0; i < count; i++) {
			f = new File("oos_" + i + ".dat");

			FileOutputStream fos = new FileOutputStream(f);
			ObjectOutputStream oos = new ObjectOutputStream(fos);
			oos.writeObject(dat);
			oos.flush();
			oos.close();
			fos.close();
		}
		time = System.currentTimeMillis() - time;
		System.out.println("oos-time : " + time);
		System.out.flush();

		//
		// LOADING
		//
		System.out.println("Streaming in: " + count + " x " + size + " doubles");
		dat.initializeByRandom(0);

		// loading using a DataOutputStream
		time = System.currentTimeMillis();
			for (int i=0; i<count; i++) {
				f = new File("dos_" + i + ".dat");
				dat.loadManuallyDataInputStream(f);
			}
		time = System.currentTimeMillis() - time;
		System.out.println("dis-time : " + time); System.out.flush();

		// loading using an ObjectInputStream
		@SuppressWarnings("unused")
		MyData du;
		time = System.currentTimeMillis();
		for (int i = 0; i < count; i++) {
			f = new File("oos_" + i + ".dat");

			FileInputStream fis = new FileInputStream(f);
			ObjectInputStream ois = new ObjectInputStream(fis);
			du = (MyData) ois.readObject();
			ois.close();
			fis.close();
		}
		time = System.currentTimeMillis() - time;
		System.out.println("ois-time : " + time);
		System.out.flush();
	}

	public static void main(String[] args) throws IOException, ClassNotFoundException {
		streamTest();
		
		System.out.println("\nFINISHED");
	}
}

 

[kopfsalat]

... iss schon spät. Ich wars...
... jetzt aber erstmal in die Heia...

 

[Bert Brenner]

BufferedOutputStream verwenden könnte noch was bringen

 

[Wildcard]

Und SysOuts rausmachen sollte auch was bringen, weil's die Messung verfälscht...

 

[homer65]

Dann gibt es da noch mit NIO mehrere Pakete für IO Verarbeitung.

 

[kopfsalat]

Danke für die Tipps!

Ein einfaches

FileOutputStream fos = new FileOutputStream(f);
BufferedOutputStream bos = new BufferedOutputStream(fos);
ObjectOutputStream oos = new ObjectOutputStream(bos);

anstelle

FileOutputStream fos = new FileOutputStream(f);
ObjectOutputStream oos = new ObjectOutputStream(fos);

hat tatsächlich schon einen gewissen Speedup gebracht. Buffered ist also fixer.

Aber die FileChannels mit den Buffern aus dem java.nio-package sind nochmals deutlich schneller!

Für 10.000.000 double-Werte (also 80MB) benötigen die Methoden nun etwa (gemittelt über 50 Durchläufe):
Speichern per BufferedOO: 960 ms
Speichern per FileChannels: 360 ms
Laden per BufferedOO: 1200 ms
Laden per FileChannels: 390 ms

zum Vergleich noch die Daten der .exe-Datei:
Speichern per exe-Datei: 700ms
Laden per exe-Datei: 180ms

Die braucht also für das Speichern länger, ist aber beim Laden fixer.

Ich habe auch noch mit den FileMapping-Routinen (per FileChannel.map(..)) gespielt und damit nochmals deutlich schnellere Zeiten als mit Channels und Buffern erzeugt. Allerdings gab es da teilweise rapide Einbrüche, wenn eine Datei, in die durch Mapping geschrieben wurde kurz darauf wieder per Mapping eingelesen werden sollte. Die Javadocs verweisen auch nur auf unbeeinflussbares Verhalten des Betriebssystem, und dass nicht festgelegt werden kann, wann das FileMapping wieder freigegeben wird.

Am sichersten + schnellsten erscheinen mir daher die FileChannels mit Buffern.

Hier noch die von mir verwendeten Methoden.

private double[] data;
	private static final int NUMELEMS = 4096;
	private static final int ELEMSIZE = 8; // 8 bytes a double 

	public void saveViaChannels(File file) throws IOException {
		FileOutputStream fout = new FileOutputStream(file);
		FileChannel fc = fout.getChannel();

		// create a byte-buffer
		ByteBuffer buffer = ByteBuffer.allocateDirect(NUMELEMS * ELEMSIZE);
			
		// write the arrays size as Double (no trouble, because each int is mapped to double without loss of precision)
		buffer.putDouble(data.length);
		buffer.flip();
		fc.write(buffer);
		buffer.clear();

		// create a double-buffer on the buffer
		DoubleBuffer dBuffer = buffer.asDoubleBuffer();
		dBuffer.clear();
		
		// write the array until far to the end 
		int i=0;
		while (i < data.length - NUMELEMS) {
			// add the data to dBuffer
			dBuffer.put(data, i, NUMELEMS);
			dBuffer.clear();
			
			// reset the buffer-marks (independant of dBuffer-marks) and write buffer
			buffer.position(0);
			buffer.limit(NUMELEMS*ELEMSIZE);
			fc.write(buffer);
			
			i += NUMELEMS;
		}

		// add the rest of data to dBuffer
		dBuffer.put(data, i, data.length-i);
		dBuffer.clear();
		
		// reset the buffer-marks and write buffer
		buffer.position(0);
		buffer.limit((data.length - i)*ELEMSIZE);
		fc.write(buffer);

		// close the stream (also channel)
		fout.close();
	}
	
	public void loadViaChannels(File file) throws IOException {
		FileInputStream fin = new FileInputStream(file);
		FileChannel fc = fin.getChannel();

		// create a byte-buffer and a DoubleBuffer on it
		ByteBuffer buffer = ByteBuffer.allocateDirect(NUMELEMS * ELEMSIZE);
		DoubleBuffer dBuffer = buffer.asDoubleBuffer();
		
		// fill the buffer the first time
		int len = fc.read(buffer);
		if (len % 8 != 0) {
			System.err.println("blocklength read not 8-byte-aligned! This should not happen and is not handled atm.");
		}
		dBuffer.position(0);
		dBuffer.limit(len / 8);
		
		// create the new data-array of correct size and wrap a new DoubleBuffer around  
		data = new double[(int) dBuffer.get()];
		DoubleBuffer dataBuffer = DoubleBuffer.wrap(data);
		dataBuffer.clear();
		
		// put the current dBuffer into the dataBuffer
		dataBuffer.put(dBuffer);

		// reset for a new read
		buffer.clear();
		len = fc.read(buffer);
		while (len >= 0) {
			if (len % 8 != 0) {
				System.err.println("blocklength read not 8-byte-aligned! This should not happen and is not handled atm.");
			}
			dBuffer.position(0);
			dBuffer.limit(len / 8);

			// put the current dBuffer into the dataBuffer
			dataBuffer.put(dBuffer);

			// reset for a new read
			buffer.clear();
			len = fc.read(buffer);
		}

		// close the stream (also channel)
		fin.close();
	}

Ab einer NUMELEMS von 33041 also mal 8 = 264328 Bytes Buffergröße bricht bei mir die Laufzeit übrigens rapide ab, das hängt wahrscheinlich mit irgendwelchen Festplatteneigenschaften zusammen. Unter dieser Grenze ist aber die Buffergröße relativ egal, deswegen habe ich einfach mal nur 4096 genommen.