Moderator: Moderatoren
Code: Alles auswählen
FATAL ERROR LOG
Not recoverable Error!
SYS Thread-ID: 1144
Module: MOM
Error Codes: EH: 1006 Sub: 0(0) OS: 0 XPP: 15
Call Stack of Thread 1 (392):
MAIN(199)
Call Stack of GUI Thread (580):
Call Stack of Thread 3 (1032):
Call Stack of Thread 4 (1144):
GEDCOMEINLESEN2(248)
(B)GEDCOMEinlesen1(89)
@XBPPUSHBUTTON@I@HANDLEEVENT(968)
GEDCOMEINLESEN1(149)
File: E:\Programme\MeinProgramm\MeinProgramm.exe
TimeStamp: 20090918 21:48
End of FATAL ERROR LOG.
schon mal in den Taskmanager und Speicheranzeige geguckt ?Jan hat geschrieben:Ich lese eine 44 MB große Ttextdatei ein. Die einzelnen Zeilen werden dabei in ein Array eingelesen. Bei ca. 1,9-2,0 Mio. Arrayelementen stürzt das Programm mit einem XppFatal ab. Die sieht so aus:Code: Alles auswählen
FATAL ERROR LOG Not recoverable Error! SYS Thread-ID: 1144 Module: MOM Error Codes: EH: 1006 Sub: 0(0) OS: 0 XPP: 15
da hast verbrauchst du halt auch ganz schön RAM ... hast du mal versucht die Datei im Ganzen in den RAM zu laden ?Jan hat geschrieben:Ich habe mir im Moment damit beholfen, daß ich das alles ein eine dbf einlesen. Aber die ist dann gleich mal 1,3 GB groß (ich lege die Feldlänge prophylaktisch mit 500 Zeichen an, wovon meist nur 10-100 Zeichen gebraucht werden), und das geht natürlich auch alles wesentlich langsamer. Ich würde das also sehr gerne wieder als Array durchlaufen lassen.
Jan
wow da "kracht" es schon viel früher bei mir.Jan hat geschrieben:ich habe mal gleich von vorneherein das Array mit 500.000 Zeilen angelegt. Totalabsturz beim Einlesen an gleicher Stelle. Hat also nichts gebracht.
Code: Alles auswählen
#include "Fileio.ch"
#include "os.ch"
#include "common.ch"
#DEFINE CRLF CHR(13)+CHR(10)
#define F_HANDLE 1
#define F_POS 2
#define F_LASTREC 3
PROCEDURE Main(cFile)
*LOCAL cFile := "E:\GIGA\BIGFILE.TXT"
LOCAL nHandle := 0
LOCAL i := 1
LOCAL Imax := 500000
LOCAL cText := ""
LOCAL nLen := 0
LOCAL nbyte := 0
LOCAL nSum := nbyte
LOCAL nTimeON := 0
LOCAL nTimeOFF := 0
LOCAL xMemo := SPACE(1024)
SET ALTER TO GIGALOG.TXT
SET ALTER ON
IF FILE(cFile)
ELSE
nHandle := FCreate(cFile, FC_NORMAL )
IF nHandle == -1
? "Fehler beim Erzeugen der Datei:", FError()
ELSE
nTimeON := SECONDS()
i := 1
FOR i := 1 TO 98
cText := cText + "Inhalt FELD"+STRZERO(i,2)+" mit Delimiter und länger"+";"
NEXT
cText := cText + "Inhalt FELD"+STRZERO(99,2)+" mit Delimiter und länger"+CRLF
nLen := LEN(cText)
nTimeOFF := SECONDS()
? LTrim(STR(nTimeOFF-nTimeON))+" sec."
SET ALTER OFF
nTimeON := SECONDS()
i := 1
FOR i := 1 TO iMax
nbyte := FWrite( nHandle, cText, nLen )
nSum := nSum+nbyte
? i,nbyte,nSum
NEXT
FClose( nHandle )
nTimeOFF := SECONDS()
SET ALTER ON
? LTrim(STR(nTimeOFF-nTimeON))+" sec."
SET ALTER OFF
ENDIF
ENDIF
IF FILE(cFile)
nTimeON := SECONDS()
//
// NO Chance with 1.5GB ???
//
* xMemo := MEMOREAD(cFile)
xMemo := MYMEMOREAD(cFile)
nTimeOFF := SECONDS()
SET ALTER ON
? LTrim(STR(nTimeOFF-nTimeON))+" sec."
SET ALTER OFF
ENDIF
SET ALTER TO
RETURN
FUNCTION MYMEMOREAD(cFile)
LOCAL aBig := {}
LOCAL aFile
LOCAL cZeile := ""
LOCAL nBisEOF := 4000 // bei 4KB Block
LOCAL nTimeON := 0
LOCAL nTimeOFF := 0
LOCAL nSum := 0
LOCAL nCounter := 0
LOCAL nMenge := 10 // 10 S„tze auf ein mal
LOCAL nMem := Memory(MEM_VIRT_AVAIL)
LOCAL nStart := 1
LOCAL nlast := 0
SET ALTER ON
? cfile,"Memory "+STR(nMem)
aFile := F_Use(cFile) // Datei ”ffnen
? F_Bof( aFile ) // Ergebnis: .T.
//
// diese Routine zielt auf "gleich" Satzl„nge ab,
// do muss man die jedesmal "berechnen"
//
cZeile := F_Read( aFile, nBisEOF ) // lange Zeile lesen
nBisEOF := AT(CRLF,cZeile)
IF nBisEOF > 0
nBisEOF := nBisEOF +2 // CRLF
? LTRIM(STR(nBisEOF))+" byte zu lesen pro/Satz"
nBisEOF := nBisEOF
ELSE
MSGBOX("reicht nicht")
QUIT
ENDIF
//
// wieder zurck auf Start
//
F_GoTop( aFile )
SET ALTER OFF
nTimeON := SECONDS()
DO WHILE ! F_Eof( aFile ) // Jeweils "Block" lesen
//
// aktuelle Position speichern
//
nlast := F_Skip( aFile, 0 )
//
// Block lesen
//
cZeile := F_Read( aFile, (nBisEOF * nMenge) ) // Daten "Block" von "nMenge" S„tzen lesen
//
// am Ende nur noch Satzweise
//
IF LEN(cZeile) <> (nBisEOF * nMenge)
F_Goto( aFile, nlast )
nMenge := 1
ELSE
//
// nun den Block in Sa„tze zerlegen
//
i := 1
FOR i := 1 TO nMenge
cTeil := SUBSTR(cZeile,nStart,(i * nBisEOF))
AADD(aBig, cTeil)
nCounter++
nSum := nSum + LEN(cTeil)
nStart := i * nBisEOF
NEXT
ENDIF
//
// das mach es langsam, aber wir wollen ja was sehen
//
IF ((nCounter) % 1000) == 0
nMem := Memory(MEM_VIRT_AVAIL)
nTimeOFF := SECONDS()
SET ALTER ON
? nCounter,nMem,nSum, LTrim(STR(nTimeOFF-nTimeON))+" sec."
SET ALTER OFF
//
// not enought Memory
//
IF Memory(MEM_VIRT_AVAIL) < 10000
* MSGBOX("Memory only "+STR(nMem))
F_GoBottom( aFile )
ENDIF
ENDIF
ENDDO // erreicht ist
FClose( aFile[F_HANDLE] )
nTimeOFF := SECONDS()
IF Memory(MEM_VIRT_AVAIL) < 10000
MSGBOX("Memory only "+STR(nMem))
SET ALTER ON
? LTrim(STR(nTimeOFF-nTimeON))+" sec. bis einlesen in aBIG Array"
SET ALTER OFF
ELSE
SET ALTER ON
? LTrim(STR(nTimeOFF-nTimeON))+" sec. zum einlesen in aBIG Array"
SET ALTER OFF
ENDIF
nSum := 0
nMenge := LEN(aBig)
SET ALTER ON
? "Array hat "+LTRIM(STR(nMenge))+" Elemente"
SET ALTER OFF
nTimeON := SECONDS()
FOR i := 1 TO nMenge
* ? aBig[i]
nBisEOF := LEN(aBig[i])
nSum := nSum +nBisEOF
NEXT
nTimeOFF := SECONDS()
SET ALTER ON
? "Items "+STR(nMenge)+" Mbyte "+STR(nSum/1000/1000)
? LTrim(STR(nTimeOFF-nTimeON))+" sec."
SET ALTER OFF
RETURN aBig
** Datei öffnen
FUNCTION F_Use( cFileName )
LOCAL aFile := { 0, 0, 0 }
aFile[ F_HANDLE ] := FOpen( cFileName, FO_READWRITE )
IF FError() == 0
aFile[ F_LASTREC ] := FSeek( aFile[F_HANDLE], 0 , FS_END )
FSeek( aFile[F_HANDLE], 0 , FS_SET )
ENDIF
RETURN aFile
** Zum Dateianfang gehen
FUNCTION F_GoTop( aFile )
aFile[ F_POS ] := FSeek( aFile[F_HANDLE], 0 , FS_SET )
RETURN NIL
** Zum Dateiende gehen
FUNCTION F_GoBottom( aFile )
aFile[ F_POS ] := FSeek( aFile[F_HANDLE], 0 , FS_END )
RETURN NIL
** Dateizeiger um nBytes "skippen"
FUNCTION F_Skip( aFile, nBytes )
aFile[ F_POS ] := FSeek( aFile[F_HANDLE], nBytes, FS_RELATIVE )
RETURN aFile[ F_POS ]
FUNCTION F_Goto( aFile, nBytes )
DEFAULT nBytes TO 1
aFile[ F_POS ] := FSeek( aFile[F_HANDLE], nBytes, FS_SET )
RETURN aFile[ F_POS ]
** Zeichen einlesen
FUNCTION F_Read( aFile, nBytes )
LOCAL cBuffer := Space( nBytes )
nBytes := FRead( aFile[F_HANDLE], @cBuffer, nBytes )
aFile[ F_POS ] += nBytes
RETURN Left( cBuffer, nBytes )
** BOF abfragen
FUNCTION F_Bof( aFile )
RETURN aFile[ F_POS ] == 0
** EOF abfragen
FUNCTION F_Eof( aFile )
RETURN aFile[ F_POS ] == aFile[ F_LASTREC ]
*
*eof
*
Die Bezeichnung Auslagerungsdatei im Windows-Taskmanager ist leider irreführend. Der Wert der hier erscheint ist der verbrauchte physikalische Speicher zusammen mit der Auslagerungsdatei.Ich habe 2 GB Arbeitsspeicher, dazu noch die Auslagerungsdatei.
Code: Alles auswählen
oTxt := HBText(cFileName,cAnsiOemW,IsFixed,lReadOnly,lExclusive)
oTxt:FileName()
oTxt:FilePath()
oTxt:SaveTo() // hier könnte man auch über einen Filter die Zieldatei verkleinern ...
oTxt:GoTop()
oTxt:GoBotom()
oTxt:GoEof()
oTxt:GetData([nLine]) // bestimmte Zeile lesen
oTxt:Skip(nLines)
oTxt:SetData([nLine])
oTxt:RecNo()
oTxt:GoTo(nLine)
oTxt:SetFilter(bFilter) // Codeblock auch in Textform -> bFilter := &(bFilter)
oTxt:AppendData(cRecord) // freies Format !
oTxt:SetVarNames(aStru) // Array mit Strukturinfos bei festen Zeilenlängen.
oTxt:?VariablenName? // VariablenName wie in SetVarNames(aStru) definiert -> :set/getNoIVar ...
oTxt:deleteFile() // warum nicht
oTxt:renameFile() ...
Dazu mache ich gleich noch ein neues Thema auf. Code: Alles auswählen
*-------------------------------------------------------------------------------
FUNCTION TxtFile2Array(cDateiName,cConvert) // TXT einlesen und zeilenweise in Array einlesen
// cConvert: NIL / empty - nichts tun
// O2A - Oem 2 Ansi
// A2O - Ansi 2 Oem
local cDateiInhalt, aZeilen := {}, nVon, nBis, cTxt
DEFAULT cConvert to ""
nVon := 1
nBis := 0
if file(cDateiName)
cDateiInhalt := memoread(cDateiName)
if ! empty(cDateiInhalt)
cConvert := upper(alltrim(cConvert))
do case
case cConvert == "O2A"
cDateiInhalt := ConvToAnsiCP(cDateiInhalt)
case cConvert == "A2O"
cDateiInhalt := ConvToOemCP(cDateiInhalt)
endcase
do while .t.
nBis := at(CRLF,cDateiInhalt,nVon)
if nBis = 0 // Ende der Datei wurde erreicht, letzten Satz nicht vergessen
cTxt := substr(cDateiInhalt,nVon)
nVon := len(cDateiInhalt)+1
else
cTxt := substr(cDateiInhalt,nVon,nBis-nVon)
nVon := nBis+2
endif
cTxt := strTran(cTxt,CRLF,"") // entferne die CRLF am Zeilenende
aadd(aZeilen,cTxt)
if nVon > len(cDateiInhalt)
exit
endif
enddo
endif
endif
return aZeilenCode: Alles auswählen
aZeilen := wToken(cGroßerString, CRLF)
nAnz := len(aZeilen)
for i := 1 to nAnz
aSpalten := wToken(aZeilen[i], ";")
next
wirklich kurios ist das eigentlich nicht. Dabei wird im Prinzip das gesamte Array intern umkopiert - so zu arbeiten ist am uneffektivsten (naja, fast), da extrem zeitaufwändig!Markus Walter hat geschrieben:Kurioserweise hat aadd am besten funktioniert (da ist die Schleife am weitesten gekommen).