Hi,
ich habe einen kleinen Test geschrieben (der Code ist so, wie er ist, unsicher, das ist mir klar. Soll nur ein Test sein...) und ihn mit einem C-Äquivalent verglichen.
Leider kackt die Java-Implementation gegen den C-Code ab (3.020s vs. 1.714s).
Es geht darum große Dateien zu kopieren und dort, wo es möglich ist, soll die Datei in einem Stück gelesen und geschrieben werden.
Dies habe ich so umgesetzt (wie gesagt: Der Code ist so noch ziemlich unsicher. Ist nur ein Test...)
Zum Vergleich die C-POSIX-Implementierung:
Danke im Voraus!
Liebe Grüße
Reality
ich habe einen kleinen Test geschrieben (der Code ist so, wie er ist, unsicher, das ist mir klar. Soll nur ein Test sein...) und ihn mit einem C-Äquivalent verglichen.
Leider kackt die Java-Implementation gegen den C-Code ab (3.020s vs. 1.714s).
Es geht darum große Dateien zu kopieren und dort, wo es möglich ist, soll die Datei in einem Stück gelesen und geschrieben werden.
Dies habe ich so umgesetzt (wie gesagt: Der Code ist so noch ziemlich unsicher. Ist nur ein Test...)
Java:
import java.io.*;
public class FileCopy {
public static void main(String[] args) {
String strSourceFile = args[0];
String strDestinationFile = args[1];
try {
//create FileInputStream object for source file
File fSource = new File(strSourceFile);
FileInputStream fin = new FileInputStream(strSourceFile);
//create FileOutputStream object for destination file
FileOutputStream fout = new FileOutputStream(strDestinationFile);
byte[] b = new byte[(int) fSource.length()];
int noOfBytes = 0;
System.out.println("Copying file using streams");
//read bytes from source file and write to destination file
noOfBytes = fin.read(b);
fout.write(b, 0, noOfBytes);
System.out.println("File copied!");
//close the streams
fin.close();
fout.close();
}
catch(FileNotFoundException fnf)
{
System.out.println("Specified file not found :" + fnf);
}
catch(IOException ioe)
{
System.out.println("Error while copying file :" + ioe);
}
}
}
Zum Vergleich die C-POSIX-Implementierung:
Java:
#include <stdio.h> /* fprintf */
#include <string.h> /* strerror */
#include <stdlib.h>
#include <fcntl.h> /* open, O_RDONLY, O_WRONLY, O_CREAT, O_EXCL */
#include <sys/stat.h> /* mode_t, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH */
#include <unistd.h> /* read, write */
#include <errno.h> /* errno */
int main(int argc, char *argv[])
{
const mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; /* rw-r--r-- */
int in, out; /* Dateideskriptoren */
unsigned char *b;
int size;
struct stat buf;
if (argc != 3)
{
fprintf(stderr, "Aufruf: %s Quelle Ziel\n", argv[0]);
return 1;
}
in = open(argv[1], O_RDONLY);
if (in == -1)
{
fprintf(stderr,
"Quelle %s kann nicht geoeffnet werden (errno %d: %s)\n",
argv[1], errno, strerror(errno));
return 1;
}
if (fstat(in, &buf) == -1)
{
fprintf(stderr,
"Es konnten keine Informationen aus Quelle '%s' ausgelesen werden (errno %d: %s)\n",
argv[1], errno, strerror(errno));
return 1;
}
size = (int) buf.st_size;
printf("Größe: %d\n", size);
b = (unsigned char*) malloc(sizeof(unsigned char) * size);
out = open(argv[2], O_WRONLY | O_CREAT | O_EXCL, mode);
if (out == -1)
{
fprintf(stderr,
"Ziel %s kann nicht erzeugt werden (errno %d: %s)\n",
argv[2], errno, strerror(errno));
return 1;
}
if (read(in, b, size) == -1)
{
fprintf(stderr,
"Quelle %s kann nicht gelesen werden (errno %d: %s)\n",
argv[1], errno, strerror(errno));
return 1;
}
if (write(out, b, size) == -1)
{
fprintf(stderr,
"Schreibfehler (errno %d: %s)\n", errno, strerror(errno));
return 1;
}
close(out);
close(in);
free(b);
return 0;
}
Danke im Voraus!
Liebe Grüße
Reality