Effizientes einlesen von großen Textdateien

mrt · 11. Mai 2016

Hallo,

ich lese gerade Textdateien (CSV) ein und verarbeite diese Zeilenweise. Das funktioniert eigentlich soweit so gut. ich habe beispielsweise eine 7 MB große Textdatei mit ~73.000 Zeilen.
Mit einem ZeilenCounter lasse ich ich mir alle 5000 Zeilen den aktuellen Zeilenstand ausgeben. Für 73k Zeilen hat nun ein durchlauf ca. 5 Minuten gedauert.

Das ist mir viel zu lang, vorallem wenn ich bedenke dass ich eine weitere Datei haben mit 130 MB und ~120.000 Zeilen

Kann man das beschleunigen?

Thnx im voraus und VG
Mrt

Ben · 11. Mai 2016

hi,
5min ist echt sehr langsam. Mit sicherheit kann man das beschleunigen, dafür müsstest du aber mal deinen code zeigen

mrt · 12. Mai 2016

Zitat von ChampS

dafür müsstest du aber mal deinen code zeigen

Ich möchte gerne in meiner App öffentliche Nahverkehrsdaten (GTFS) öffnen, wie zB. das von Berlin. Die gezippte Datei ist beispielsweise ca. 30 MB groß. Entpackt hat beispielsweise die trips.txt etwas über 11 MB mit knapp 232.000 Zeilen.

Hier die Methode welche die Datei Zeilenweise ausließt (achja, die Dateien sind entpackt im assets Ordner, was ja perse etwas langsamer sein soll als zB SD Karte):

EDIT: Habe einiges optimiert, siehe "AUSkommentare"

Java

private void readTrips(AssetManager a) {


        Log.d(TAG, " Start reading file...");


        int lineNumber = 0;


        BufferedReader reader = null;
        try {
            reader = new BufferedReader(
                    new InputStreamReader(a.open("trips.txt")));


            // do reading, usually loop until end of file reading
            String mLine = reader.readLine(); // erste Zeile
            while ((mLine = reader.readLine()) != null) {
                //if (lineNumber &gt; 0)
                //{
                    parseTripsByLine(mLine);
                //}
                lineNumber++;
            }
        } catch (IOException e) {
            Log.e(TAG, e.getLocalizedMessage());
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    Log.e(TAG, e.getLocalizedMessage());
                }
            }
        }
}

Alles anzeigen

UInd hier das zerlegen der einzelnen Zeile:

Java

private long parseTripsByLine(String line) {
        String[] trip_properties = line.split(",");


        // error codes
        //if (trip_properties.length &lt; 1) {
        //    Log.d(LOG_TAG, "Empty line!");
        //    return -2; // empty line
        //} else if (trip_properties.length &lt; 4) {
        //    return -3; // incomplete data chunk
        //} else if (line.indexOf('"') != 0 || line.contains("route_id")) {
        //    return -4; // first line
        //}


        String route_id = StringUtils.chopFirstAndLast(trip_properties[0]);
        String service_id = StringUtils.chopFirstAndLast(trip_properties[1]);
        String trip_id = StringUtils.chopFirstAndLast(trip_properties[2]);
        String shape_id = StringUtils.chopFirstAndLast(trip_properties[3]);
        String trip_headsign = StringUtils.chopFirstAndLast(trip_properties[4]);


				int t = -1;
        try{
            t = Integer.parseInt(StringUtils.chopFirstAndLast(trip_properties[5]).replace("\"", ""));
        } catch (NumberFormatException e)
        {
            Log.e(LOG_TAG, "trip_direction_id was NOt set. Use default trip_direction_id " + Constants.DEFAULT_DIRECTION + " in database." );
        }


        String block_id = StringUtils.chopFirstAndLast(trip_properties[6]);


        // populate container
        return tripsDB.addTrip( route_id,
                                service_id,
                                trip_id,
                                shape_id,
                                trip_headsign,
                                t,
                                block_id );


    }

Alles anzeigen

Ben · 12. Mai 2016

Es ist wichtig erstmal rauszufinden was den leseprozess so langsam macht. Ich glaube nicht dass das einlesen solang dauert, vermutlich wird parseTripsByLine extrem langsam sein. Wie mir scheint verwendest du eine third party bibliothek um deine Strings aufzuteilen. Kannst du mal versuchen die StringUtils.chopFirstAndLast methode wegzulassen und dann nochmal zu messen wieviel zeit das einlesen benötigt? Es ist erstmal egal ob interpretierbare werte durch das weglassen der methode herauskommen. Es geht ja nur um das debugging.

mrt · 13. Mai 2016

Zitat von ChampS

Wie mir scheint verwendest du eine third party bibliothek um deine Strings aufzuteilen. Kannst du mal versuchen die StringUtils.chopFirstAndLast methode wegzulassen und dann nochmal zu messen wieviel zeit das einlesen benötigt?

Es ist eine FirstPartyLibrary

Java

public static String chopFirstAndLast(String rawString)
    {
        return rawString.substring(1, rawString.length()-1);
    }

Nur ne statische Methode, die das erste und letze Gänsefüßchen wegmacht. Aber ich stoppe mal die Zeit. Hm ok krass, dass da ne Minute unterschied ist, hätt ich nicht gedacht.:

Alle 10.000 Zeilen lasse ich mir nen log auf die console ausgeben:

- 10.000 Zeilen mit der chop*-Methode ~ 150 Sek (~2,5 Min.) und 730.000 byte DB größe
- 10.000 Zeilen ohne der chop*-Methode ~ 90 Sek (~1,5 Min.) und dafür 820.000 byte DB größe

Ben · 13. Mai 2016

du sagtest im ersten post das dauert 5min, also doch nicht ganz soviel
2,5min waren aber mMn auch zuviel, ich denke auch 90s ist noch zuviel.
Mhh mach mal alle textverändernden sachen raus und teste das reine auslesen. Vorallem trenne das Auslesen, vom in die Datenbank schreiben und messe beide Zeiten. Es kann nämlich auch sein das jetzt die 90s nicht durch das auslesen der daten aus dem File zustande kommen sondern durch das schreiben in die Datenbank.

Erst wenn du die Messdaten vom reinen lesen und vom reinen in die Datenbank schreiben hast, kannst du dann irgendwelche string-operationen auf deine strings anwenden. Nach jeder String-Operation würde ich dann nochmal messen und schauen warum es aufeinmal eine Minute länger dauert.

JavaScript

public static String chopFirstAndLast(String rawString)
    {
        return rawString.substring(1, rawString.length()-1);
    }

Das solltest du vielleicht auch noch mit dem hier ersetzen.

Java

public static String chopFirstAndLast(String rawString)
    {
        return rawString.replace('"', '');
    }

Marco Feltmann · 23. Mai 2016

Du arbeitest 73.000 Einträge zeilenweise ab, gibst 73.000 Logausgaben aus, erstellst 73.000 Arrays über eine String-Methode und erzeugst 73.000 Datenbankeinträge.
Ist Dir schon einmal der Gedanke gekommen, dass das ganz eventuell ein kleines bisschen Zeit braucht?
Deutlich weniger als von Hand, aber trotzdem.

Das LG G3 ist auch etwas betagt und daher etwas langsam.

Ich mein ja nur. 73.000x nix machen mit der Low-Level-Sprache C auf einem 1.6GHz Quadcore it 8GB RAM braucht ungefähr 0.02 Sekunden.

C

#include &lt;stdio.h&gt;
#include &lt;time.h&gt;


int main ( int argc, char ** args ) {


  clock_t start = clock();


  static int dummy = 0;


  for( int i=0; i&lt;=73000;i++) {


    // Schleife leer lassen bringt nix, sonst wird die knallhart wegoptimiert.
    dummy = i * 2;


    printf(".");
  }


  clock_t end = clock();


  printf("\n\nDauer: %f", ( difftime(end, start) / CLOCKS_PER_SEC ) );


  return 0;
}

Alles anzeigen

Zitat

Dauer: 0.024070

(Bei leerer Schleife ohne statische Variable 0.000355...)

Bau sowas mal in Java nach und teste das mal direkt auf Deinem Ubuntu und dann auf Deinem LG G3.

Optimierungspunkt 1)
Nimm irgendwie die Datenbankzugriffe raus. Vermeide Operationen auf dem Dateisystem generell.
Du könntest beispielsweise Dateneinträge sammeln und alle 100 Durchläufe im Pulk senden. (Zu langes Sammeln frisst Dir den Speicher weg.)

Optimierubgspunkt 2)
Importier den Kram mal in Excel, LibreOffice Calc oder eine ähnliche Anwendung. Da wartest Du auch ein bisschen.
Leb also einfach damit, dass das dauert und pack den Vorgang in den Hintergrund. Du kannst ja nen unbestimmten Fortschrittsbalken anzeigen und am Ende eine Notification senden.

mrt · 24. Mai 2016

Zitat von Marco Feltmann

gibst 73.000 Logausgaben aus

Logausgaben gibts nur eine am Anfang und dann nur bei Exceptions. Aber das mit den Arrays stimmt, und natürlich die Datenbankzugriffe. Ich werd dann niochmal ne Reihe ohne diese Zugriffe starten

Ben · 24. Mai 2016

man kann damit leben das etwas lange dauert, man kann aber auch ein wenig daran optimieren mit es nicht mehr ganz solang dauert

Effizientes einlesen von großen Textdateien

Jetzt mitmachen!

Teilen