Laufzeiten und GNU/Watcom C

Joachim D. schrieb:
> Wonach müßte ich da suchen?

Das ist nur so schwer zu sagen. Kannst du denn ein paar Codeschnipsel, 
die das fragliche Datei-Handling vornehmen, posten?

Wenn ich sowas simples aufsetze:

1

#include <stdio.h>

2

3

int

4

main(int argc, char **argv)

5

{

6

  if (argc < 2)

7

    return 1;

8

9

  FILE *f;

10

  if ((f = fopen(argv[1], "r")) == NULL)

11

    return 2;

12

13

  char line[200];

14

  int lineno = 0;

15

16

  while (fgets(line, sizeof line, f)) {

17

    lineno++;

18

  }

19

  printf("Read %d lines\n", lineno);

20

21

  return 0;

22

}

und auf eins der Dictionaries loslasse, geht das in Millisekunden:

1

% time ./foo /usr/share/dict/swiss 

2

Read 356108 lines

3

0.010u 0.000s 0:00.01 100.0%    0+0k 0+0io 0pf+0w

4

% time ./foo /usr/share/dict/ngerman 

5

Read 356008 lines

6

0.011u 0.000s 0:00.01 100.0%    0+0k 6672+0io 0pf+0w

Beide Dateien sind 4,5 MiB groß, also in dieser Hinsicht ungefähr 
vergleichbar mit deiner.

Hmmmm...

der Code ist ja gleich. Ich habe so das "Gefühl" da passiert
irgndwoanders etwas. Ich habe nur kaum Erfahrungen mit dem
GNU - und eigentlich keinen Plan wo da die Fallstricke sein
könnten. So einenn extremen Laufzeitunterschied habe ich
noch nie erlebt. Das ist fast wie GWBASIC und C :)

Selbst ein zu Jörgs Testprogramm äquivalentes Python-Programm braucht
nur 66 ms. Der Großteil der Zeit entfällt dabei auf das Laden und
Starten des Interpreters. Der eigentliche Einlesevorgang dauert gerade
einmal 3 ms.

Joachim D. schrieb:
> Mit Watcom kompiliert: Laufzeit 100 msec
> Mit GNU kompiliert: Laufzeit 17 sec (!)

Der Faktor von 170 lässt sich fast nur durch einen Programmfehler
(undefined Behavior, Buffer Overflow o.ä.) erklären, der dazu führt,
dass das Programm – abhängig vom verwendeten Compiler – Dinge tut, die
es gar nicht tun sollte.

Mach den Fehler weg, dann wird das Programm auch mit GCC in 100 ms (oder
noch schneller) laufen ;-)

Den Fehler (ich denke nicht daß da einer ist) würde ich
ja gerne wegmachen. Das Problem muß vor dem Laden auftreten
(ok, 100 ms sind lange, aber ich lese das dann noch in interne
Strukturen ein).

Profiler wäre mal einen Versuch wert ...

derMosphet schrieb:
> Compiler Optimierungen (-O2) sind eingeschaltet?

gibt 15,8 sec

Klar ist da ein bug ;)

time( NULL) gibt auf einmal 0 ??? Gerade gefunden.

Beim watcom macht er mit der Option 'zp1' daqs structure aligment
auf 1 Byte. Ich brauche das programmintern. Das könnte damit etwas
zu tun haben ...

Mal sehen wie der GCC das so macht ;)

mh schrieb:
> Du änderst mit einer Compileroption das Alignement für alle Strukturen?

Ja.

Das ganze SSL-Zeuch mal totgelegt und #pragma pack(1) ganz
oben ins erste Headerfile.

Es ändert sich nichts.

Windows 10.

W10 Webserver lokal, W10 Client mit FF (alles aktuell).

Die Rechteddatei (flat text) besteht aus Definitionen der
Benutzergruppen

group XXX {
  job (rechte)
  ...
}

user YYY {
  job (rechte)
  ...
}

etc. 72 Gruppen und knapp 15.000 User.

Der Krempel wird nach dem Laden der Rechte in entsprechende
Strukturen übertragen. Das Übertragen dauert so ewig. Im
Moment habe ich alles SSL-Zeugs raus und das Programm müßte
sich genauso verhalten als hätte ich das mit dem Watcom
kompiliert.

Die Übertragung funktioniert definitiv.

Also: Funktion ok aber halt strunzlahm ...

1. Öffnen und malloc() für Puffer
2. Laden in den Puffer
3. Entfernen aller CR, LFs
4. dann durch den String handeln und den Kram in die
   Strukuren laden

Punkt 4. schwächelt.

Die Größen der Strukuren gibt sizeof() gleich aus.

Kannst du denn nicht mal ein Stück Beispielcode zitieren, ohne nun 
gleich allerlei Firmengeheimnisse preiszugeben?

Pause ;)

Gleich kommt Besuch und ich muß noch die Schweinshaxn holen.
Am Sonntag geht weiter ;)))

Joachim D. schrieb:
> Windows 10.

Was für ein gcc ist das? mingw? cygwin? wsl?

MinGW

Umgebung: Windows 10 Client und Serverm aktuell
httpd: Apache 2.4
MinGW: 6.30
Watcom: 1.9

Ich habe jetzt mal das Programm mit der Option -pg compiliert
und laufen lassen. Dann mit gprof den output lesbar gemacht.
Den etwas merkwürdigen output (der mir nicht weiterhilft, alles
0) hängt an.

Grüße Joe und schon vielen Dank !

Edit: beim lauf von gprof kamen jede Menge Meldungen
"BFD: Dwarf Error: Could not find abbrev number 84."
Was Zwerge damit zu tun haben .... ;)

Joachim D. schrieb:
> Was Zwerge damit zu tun haben .... ;)

Diese nützlichen Zwerge verwalten die Debug-Informationen:

https://en.wikipedia.org/wiki/DWARF

Wenn die BFD-Bibliothek damit nicht klar kommt, dann ist sie wohl 
einfach mal zu alt für den Compiler.

Ich vermute allerdings eher, dass es irgendein Problem mit den 
(OS-)Timern bei dir gibt, die der Profiler-Code offenbar nicht benutzen 
kann, während die DWARF-Warnungen eher harmlos sind.

Puh. Das könnte mir gprof auch sagen. Ergo Sackgasse.

Joachim D. schrieb:
> Das könnte mir gprof auch sagen.

Dass die Timer dam Ende keine Zeit liefern, wird er wohl nicht wissen.

Ich hatte weiter oben mal nach einem minimalistischen Codebeispiel 
gefragt, kannst du sowas mal posten?

1

        if ( ! LoadRightsD())

2

                return FALSE;

3

        jDspTime( NULL, "after load rights.d");

4

5

        // Kommentare, Tabs und NL durch Blanks ersetzen

6

        for ( p=fbuf; *p; p++){

7

                if ( *p == ';'){

8

                        for ( ; *p && *p != '\n'; p++){

9

                                *p = ' ';

10

                        }

11

                }

12

                if ( *p == '\n' ||  *p == '\r' ||  *p == '\t')

13

                        *p = ' ';

14

        }

15

        jDspTime( NULL, "after blank");

16

17

        for ( grpmax=usrmax=0, p=fbuf; *p; p++){

18

                *name = *workspace = 0;

19

                if ( memcmp( p, "group", 5) == 0){

20

                        p = scword( p); sscanf( p, "%s", name);

21

                        p = scword( p);

22

                        sscanf( p, "{%[^}]", workspace);

23

                        p += strlen( workspace) + 2;

24

                        GetGroup( name);

25

//                      jDspTime( NULL, "after get grp %s", name);

26

                }

27

                if ( memcmp( p, "user", 4) == 0){

28

                        p = scword( p); sscanf( p, "%s", name);

29

                        p = scword( p); sscanf( p, "{%[^}]", workspace);

30

                        p += strlen( workspace) + 2;

31

                        GetUser( name);

32

//                      jDspTime( NULL, "after get usr %s", name);

33

                }

34

        }

scword geht hinter den nächsten whitespace auf das nächste Wort.
In fbuf liegt die eingelesene Rechtdatei.

1

        static

2

        GetGroup(

3

        char    *name

4

        )

5

{

6

        char    *p, *q, *qq, job[256], parms[256];

7

        T_RJOB  *jp;

8

        int     i;

9

10

        strcpy( group[grpmax].id, name);

11

12

        // wenn in sys.cfg $timeout gesetzt ist dann als Vorgabe für

13

        // die Gruppe übernehmen

14

15

        if ( atoi( GetSysVar( "timeout"))){

16

                group[grpmax].timeout = atoi( GetSysVar( "timeout"));

17

//              JA( "timeout preset for grp '%s' set from sys.cfg: %d sec",

18

//                group[grpmax].id, group[grpmax].timeout);

19

        }

20

21

        p = workspace;

22

        if ( *p == ' ')

23

                p = scword( p);

24

25

        for ( ; *p; p = scword( p)){

26

                *job = *parms = 0;

27

                sscanf( p, "%s", job);

28

                if ( (q = strchr( job, '.')) != NULL){

29

                        *q = 0;

30

                        q++;

31

                } else {

32

                        q = job;

33

                }

34

                if ( strcmp( job, "isapo") == 0){

35

                        group[grpmax].isapo = TRUE;

36

                        continue;

37

                }

38

                if ( strcmp( job, "privat") == 0){

39

                        group[grpmax].privat = TRUE;

40

                        continue;

41

                }

42

                if ( strcmp( job, "testip") == 0){

43

                        group[grpmax].testip = TRUE;

44

                        continue;

45

                }

46

                if ( strcmp( job, "css") == 0){

47

                        p = scword( p);

48

                        sscanf( p, "(%[^)])", group[grpmax].css);

49

                        continue;

50

                }

51

                if ( strcmp( job, "timeout") == 0){

52

                        p = scword( p);

53

                        sscanf( p, "(%[^)])", parms);

54

                        group[grpmax].timeout = atoi( parms);

55

                        continue;

56

                }

57

58

                jp = NULL;

59

                for ( i=0; i<group[grpmax].jmax; i++){

60

                        if ( strcmp( group[grpmax].jobs[i].id, job) == 0){

61

                                jp = &group[grpmax].jobs[i];

62

                                break;

63

                        }

64

                }

65

                if ( jp == NULL){

66

                        jp = &group[grpmax].jobs[group[grpmax].jmax];

67

                        group[grpmax].jmax++;

68

                }

69

                strcpy( jp->id, job);

70

71

                p = scword( p);

72

                sscanf( p, "(%[^)])", parms);

73

74

                switch ( *q) {

75

                  case 'e':     // exec in docs ablegen

76

                  case 'd':

77

                        GetAccess( &jp->docs, parms);

78

                        break;

79

                  case 'n':

80

                        GetAccess( &jp->notes, parms);

81

                        break;

82

                  case 's':

83

                        if ( *(q+1) == 'c'){

84

                                strcpy( jp->scope, parms);

85

                                trim( jp->scope);

86

                        } else {

87

                                strcpy( jp->system, parms);

88

                        }

89

                        break;

90

                  case 'f':

91

                        StoreGrpFilter( jp, parms);

92

                        break;

93

                  default : ;

94

                }

95

                qq = p;

96

                if ( (p = strchr( p, ')')) == NULL){

97

                        JA( "*** missing ')' at group '%s' > '%s'", workspace, qq);

98

                        JSSayErr( "rights.d: missing ')' at group '%s' > '%s'", workspace, qq);

99

                        break;

100

                }

101

        }

102

        if ( ++grpmax >= GRPMAX){

103

                JSSayErr( "rights.d: Mehr als %d Gruppen definiert.", GRPMAX);

104

        }

105

        return 0;

106

}

1

        static

2

        GetUser(

3

        char    *name

4

        )

5

{

6

        char    *p, *q, *qq, tag[256], parms[256];

7

8

        strcpy( usr[usrmax].id, name);

9

        usr[usrmax].fmax = 0;

10

        p = workspace;

11

        if ( *p == ' ')

12

                p = scword( p);

13

14

        if ( atoi( GetSysVar( "timeout"))){

15

                usr[usrmax].timeout = atoi( GetSysVar( "timeout"));

16

//              JA( "timeout preset for usr '%s' set from sys.cfg: %d sec",

17

//                usr[usrmax].id, usr[usrmax].timeout);

18

        }

19

20

        for ( ; *p; p = scword( p)){

21

                *tag = *parms = 0;

22

                sscanf( p, "%s", tag);

23

                if ( strcmp( tag, "isapo") == 0){

24

                        usr[usrmax].isapo = TRUE;

25

                        continue;

26

                }

27

                if ( strcmp( tag, "privat") == 0){

28

                        usr[usrmax].privat = TRUE;

29

                        continue;

30

                }

31

                if ( strcmp( tag, "testip") == 0){

32

                        usr[usrmax].testip = TRUE;

33

                        continue;

34

                }

35

                p = scword( p);

36

                sscanf( p, "(%[^)])", parms);

37

                p += strlen( parms);

38

                trim( parms);

39

                if ( (p = strchr( p, ')')) == NULL){

40

                        JA( "*** missing ')' at '%s'", usr[usrmax].id);

41

                        JSSayErr( "rights.d: missing ')' at user '%s'", usr[usrmax].id);

42

                        break;

43

                }

44

45

                switch ( *tag) {

46

                  case 't': usr[usrmax].timeout = atoi( parms); break;

47

                  case 'm': strcpy( usr[usrmax].mail , parms); break;

48

                  case 'c': strcpy( usr[usrmax].css  , parms); break;

49

                  case 'a': strcpy( usr[usrmax].abt  , parms); break;

50

                  case 'n': strcpy( usr[usrmax].name , parms); break;

51

                  case 'p': strcpy( usr[usrmax].pass , parms); break;

52

                  case 'e': strcpy( usr[usrmax].expd , parms); break;

53

                  case 'g':

54

                        strcpy( usr[usrmax].group, parms);

55

                        break;

56

                  case 'f':

57

                        sscanf( parms, "%s%s%s",

58

                          usr[usrmax].filter[usr[usrmax].fmax].id,

59

                          usr[usrmax].filter[usr[usrmax].fmax].field,

60

                          usr[usrmax].filter[usr[usrmax].fmax].op);

61

62

                        q = scword( scword( scword( parms)));

63

                        if ( (qq = strstr( q, "hide")) != NULL){

64

                                memset( qq, ' ', 4);

65

                                usr[usrmax].filter[usr[usrmax].fmax].hide = TRUE;

66

                        }

67

                        trim( q);

68

69

                        strcpy( usr[usrmax].filter[usr[usrmax].fmax].expr, q);

70

                        usr[usrmax].fmax++;

71

                        break;

72

                  default : JA( "*** invalid entry %s\nworkspace: '%s'", tag, workspace);

73

                }

74

        }

75

        usrmax++;

76

        return 0;

77

}

Wenn ich da etwas rauswerfe wird es unklar. Ich weiß,
minimalistisch ist das eher nicht. Es muß halt eine
Kleinigkeit sein an der sich der GCC verschluckt.

Der Code ist seit min 10 in dieser Form aktiv und
funktioniert. Halt mit dem Watcom besser als mit dem GCC.

Joachim D. schrieb:
> Mit GNU kompiliert: Laufzeit 17 sec (!)

Auch wenn Du den Lauf direkt danach nochmal startest? Wenn es beim 
zweiten Mal flotter geht, ist es der Virenscanner, der erstmal die neue 
EXE checkt.

Dasselbe Phänomen habe ich hier unter Windows auch, wenn ich mit mingw 
ein Windows-Programm erzeuge und danach starte.

Virenscanner ist nicht drauf.
gprof ist 2.28

Zu 1: Ja, ich habe kontrolliert was er da eingelesen hat

Zu 2: das ist etwas problematisch. Es ist halt ziemlich umfangreich.

Zum Ausprobieren habe ich das alles mal direkt in main()
unmittelbar nach dem Programmstart
aufgerufen ohne das ganze Beiwerk. Es ändert sich nichts.

Zu 3: Noch mehr tools ? Ich denke, es ist kein tuning Problem.

zu 4: MinGW legt das im Unix-Format ab, da kann M$ angeblich
nichts mit anfangen

zu 5: Ich habe irgendwo noch einen älteren Rechner mit debian.
Es muß aber in der Firma unter W10 laufen.

GetUsr() wird 14371 mal aufgerufen, also mal mit clock()
die Ticks gezählt. Alles 0, 22mal 16 ??? Eigentlich sind
die user bis auf die Kundennummer, PW und Zugriffsrechte
gleich, Wird immer doller.

Was passiert, wenn du mal

1

#define GetSysVar(foo) "42"

davor setzt?

Dieses sich wiederholende

1

atoi(GetSysVar("timeout"))

stößt mir irgendwie auf. Solch eine String->Int-Konvertierung macht man 
doch am besten nur genau einmal beim Systemstart.

Joachim D. schrieb:
> ...

Auf jeden Fall solltest du dringed deinen Code refactorn.
Das ist ja furchtbar. Da blickt ja keiner durch.

diese unsägliche  scword( p) / sscanf orgien.

es gibt eine C-Funktion, die Zerlegt dir einen String in Token:

1

   char *token;

2

   const char s[] = " ";

3

4

   /* get the first token */

5

   token = strtok(str, s);

6

7

   /* walk through other tokens */

8

   while( token != NULL ) {

9

      printf( " '%s'\n", token );

10

11

      token = strtok(NULL, s);

12

   }

Aber ich würde eher c++, streams und reguläre ausdrücke benutzen oder 
gleich ne kleine sqlite-Datenbank verwenden.



Was performance angeht:
Ansonsten ist mir das was Jörg gefunden hat auch aufgestoßen:
Jörg W. schrieb:
> GetSysVar





cppbert3 schrieb:
>>also mal mit clock() die Ticks gezählt. Alles 0, 22mal 16 ???
>
> was soll das bedeuten - 22mal 16?

Ich vermute, dass die Auflösung von clock 16ms ist und er bei den 14371 
Funktionsaufrufen 22 mal einen Taskswitch gemessen hat.

cppbert3 schrieb:
> also 14371 x 2 = 28742 Aufrufe von GetSysVar+atoi

ausgelagert. Immer noch 16,2 sec.

Vlad T. schrieb:
> Aber ich würde eher c++, streams und reguläre ausdrücke benutzen oder
> gleich ne kleine sqlite-Datenbank verwenden.

Das ist halt das System ohne SQLite. Erheblich schneller
wie das "mit" (selbstgebaute DB).

C++ nur im Notfall, wozu in einer Rechnedatei reguläre Ausdrücke ?

Joachim D. schrieb:
> Vlad T. schrieb:
>> Aber ich würde eher c++, streams und reguläre ausdrücke benutzen oder
>> gleich ne kleine sqlite-Datenbank verwenden.
>
> Das ist halt das System ohne SQLite. Erheblich schneller
> wie das "mit" (selbstgebaute DB).
>
> C++ nur im Notfall, wozu in einer Rechnedatei reguläre Ausdrücke ?

du willst mir erzählen, dass du schneller dateien lädst und nach usern 
und so durchsuchst, als sqlite?


wozu c++?
lesbarer, leichter wartbarer Code, da es eine vernünftige Lib mitbringt 
und nicht alles selbst geschrieben werden muss.
Ist mit großer Wahrscheinlichkeit auch schneller, als das ganze scanf, 
da die Typen zur Kompile-Zeit bekannt sind und nicht erst ein 
Formatstring geparst werden muss.

warum reguläre ausdrücke?
Na zum Parsen der Datensätze.
Aber da weiß ich zu wenig über deinen Aufbau, ob es den Code 
übersichtlicher oder komplizierter machen würde.

sqlite ist recht flott.

Es kommt halt eine seine Grenzen wenn da mal 100 Mio Records
zu testen sind. Ich komme da auf 0,1 sec ;)

Man muß auch nicht immer mit Kanonen auf Spatzen ...

Falls das noch nicht durch ist:

Es ist ein CGI-Programm. Der Indianer ruft das auf und möchte
natürlich so schnell wie möglich Ergebnisse sehen ...

sqlite kann ich über die DLL einbinden und verwenden. Das
dauert halt ein wenig.

strtok zerstört mir den Quellstring. Gerade beim Einlesen
von Wertepaaren nicht so toll.

Es sind nur die Teile die ich gepostet hatte. In der
Schleife bleiben die 16 sec liegen.

VTune werde ich mir mal anschauen.

Mir qualmt jetzt der Schädel - morgenm wieder ;)

Joachim D. schrieb:
> sqlite kann ich über die DLL einbinden und verwenden. Das
> dauert halt ein wenig.

man kann aber auch das amalgamation source file einfach mitkompilieren, 
dann entfällt der DLL-Ladeprozess und er linkt nur nimmt nur das mit, 
was du auch brauchst.

Joachim D. schrieb:
> strtok zerstört mir den Quellstring. Gerade beim Einlesen
> von Wertepaaren nicht so toll.

wieso?
einmal Input parsen und dann vergessen, was juckt dich, ob da ein paar 
'\0' eingestreut werden.
Ist doch sogar gut, dann können die substrings direkt verwendet werden 
und müssen nicht erst kopiert werden (es sei denn, du willst sie über 
die Lebenszeit des Inputpuffers hinaus behalten)

Joachim D. schrieb:
> Es kommt halt eine seine Grenzen wenn da mal 100 Mio Records
> zu testen sind. Ich komme da auf 0,1 sec ;)

Ist eventuell eine Frage der gewählten Indexe - dazu ist über deine 
Struktur zu wenig bekannt.

Joachim D. schrieb:
> Man muß auch nicht immer mit Kanonen auf Spatzen ...
sqlite ist keine Kanone und (d)eine User-Datenbank kein Spatz, zumal du 
mindestens 2 Tabellen mit mindestens einer Relation zwischen Benutzer 
und Gruppen hast, eventuell auch noch eine Zwischen Gruppen und 
Bereichen, auf die diese Gruppen zugriff haben.

Und mit >14000 Userneinträgen sind die ja auch gut gefüllt.

cppbert3 schrieb:
> es wäre schön wenn du aus den 3 Funktionen einen kompilierbares Beispiel
> machen könntest - also auch mit den Hilfs-Funktionen und das posten -
> vielleicht sogar mit einer gleich großen Rechte-Datei mit Fake-Daten und
> einer Format-Beschreibung :)

das wär super, dann könnte man eine kleine challange draus machen, wer 
den fixesten Parser schreibt.

Wobei ich mich immer noch am meisten wundere, wo die 16s für so ein 
Bissel Inputparsing herkommen.

sehr ungeschickt finde ich die Verwendung der Globalen Variable 
workspace, die einen Pointer auf den gesamten String bekommt.

Die Tests auf ein missing ')' sind quasi wirkungslos, weil abgesehen vom 
letzten "Datenbank"eintrag wird es in dem 4MB-String immer noch irgendwo 
eine Klammer geben.
Damit hier nennenswerte Zeiten zustande kommen, müsste aber in einem 
großem Kontinuierlichem Bereich die Klammern fehlen, aber trotzdem 
unschön.

Ich würde entweder meine Datei so definieren, dass pro Zeile ein 
Datensatz, und dann die Zeilen unabhängig voneinander prozessieren.

Oder zumindest sauber die Endtokens extrahieren und in den 
Datensatz-Parsern sauber abprüfen.

@OP:

Bei welchem C-Compiler ist das eigentlich eine (legale) 
Funktionsdefinition (, die keine Warnung wirft):

1

static

2

GetUser(

3

         char    *name

4

        )

5

{

?

Hast du dir mal deine Compilerwarnungen angeschaut?

Ich würde die So definieren:

1

static BOOL ParseUser(User* o_user, const char* i_start, const char* i_end);

(das Extrahieren des Namens gehört für mich auch nach drin)

und wenn in drin irgend welche indices bestimmt werden, immer testen, ob 
ich über das Ende der aktuellen Definition gelaufen bin.


Eine andere Sache:
sind die Strukturen denn vorher genullt?
>  for ( i=0; i<group[grpmax].jmax; i++){
jmax wurde vorher sonst noch nicht gesetzt oder so.

Das Itertieren und strcmp könnte sonst unter umständen recht lange 
dauern und müsste, je nach Größe deiner Arrays und jmax Datentyp, auch 
nicht unbedingt eine Zugriffsverletzung geben.

Das ist aktuell mein heißester Kandidat.

Ich teste das morgen erstmal in Ruhe durch.

Irgendwo muß aber ein Unterschied beider Compiler sein.
Den suche ich.

1

        for ( grpmax=usrmax=0, p=fbuf; *p; p++){

2

                *name = *workspace = 0;

3

                if ( memcmp( p, "user", 4) == 0){

4

                        p = scword( p); // sscanf( p, "%s", name);

5

                        p = scword( p); sscanf( p, "{%[^}]", workspace);

6

                        p += strlen( workspace) + 2;

7

                }

8

        }

Der Rest ist auskommenttiert.

Laufzeit ist 7,9 sec, wenn ich den Kommentar vor dem sscanf
entferne die übliche 15 sec. Deutet auf das sscanf hin.

Wenn ich mit setlocale( LC_ALL, NULL) das locale abrufe
erhalte ich "C". Ich suche noch den Schlauch auf dem
ich stehe. Die Rechtedatei enthält neben ASCII auch deutsche
Umlaute, ich kann mir aber nicht vorstellen, daß das einen
Einfluß haben könnte.

Liegt irgendwie auf der Hand ... ;(

Mein erster C-Compiler Manx Aztek konnte nur das 'C'-locale,
der Watcom (glaube ich) auch. Beim GCC ist das anscheinend
etwas komplexer.

sscanf gibt immer 1 zurück.

Es gibt keine Programme die bugfrei sind. In diesem Fall ist
ein Bug vor diesem Aufruf der sscanf abschießt unwahrscheinlich
(unmittelbar in main() ganz oben rufe ich das auf).

gprof produziert schicht Unsinn.
sizeof zeigt mir bei den verschachtelten Strukturen unter GCC
und Watcom die gleiche Größe, das sollte passen.

Joachim D. schrieb:
> char *
>         scword(
>         char     *P
>         )
> {
>         unsigned char *p;
>
>         p = (unsigned char*) P;
>         if ( isspace( *p)){
>                 for ( ; isspace( *p); p++) ;

Hier hast du vll einen Überlauf, wenn *p == \000.

Ansonsten:

1

char *scword(char *P) {

2

  char *p = P;

3

4

  // skip non-space

5

  while (*p && !isspace(*p)) {

6

    p++;

7

  }

8

9

  // skip space 

10

  while (*p && isspace(*p))  {

11

    p++;

12

  }

13

14

  return p;

15

}

Macht das gleiche, aber mMn übersichtlicher und ohne Überlauf :-)

Eric B. schrieb:
> Hier hast du vll einen Überlauf, wenn *p == \000.

Warum? Wenn *p == '\0', dann gibt iusspace(*p) 0 zurück (schließlich ist 
'\0' kein Space), und der if-Zweig wird gar nicht erst angesprungen.
Dass man die Verzweigung ganz weglassen kann, da gebe ich dir recht.

> char *p = P;

Da ist das unsigned verloren gegangen.

Dawai. Alle benutzten Funktionen sind da drinnen.

Laufzeit immer noch 16 sec

load rights.d: ellapsed time 0.3100 sec
after blank: ellapsed time 0.3250 sec
after load grp: ellapsed time 16.7340 sec

Ohne das jetzt im Detail durchgespielt zu haben, würde ich sagen, dass 
da über das Ende von fbuf hinaus gelesen wird, da p gleich an mehreren 
Stellen in der Schleife erhöht wird.

cppbert3 schrieb:
> jetzt brauchen wir noch eine Datei zum testen - kannst du was
> generieren?

Die sollte ich erst anonymisieren. Dauert ein wenig ...

structure alignment brauche ich hier eigentlich nicht. Eher bei
binären Daten wo die Strukturen hintereinander in einer Datei liegen.
Ohne #pragma gleiche Laufzeit.

Yalu X. schrieb:
> Ohne das jetzt im Detail durchgespielt zu haben, würde ich sagen, dass
> da über das Ende von fbuf hinaus gelesen wird, da p gleich an mehreren
> Stellen in der Schleife erhöht wird.

Das paßt.


loaded 3504875
load rights.d: ellapsed time 0.3160 sec
after blank: ellapsed time 0.3460 sec
p      00E17B0C
p-fubf 3504876
after load grp: ellapsed time 16.8970 sec

Danke foobar,

ich schaue mir das nachher nochmal genauer an. Ich muß jetzt
mal 2 h weg ;(.

Irgendwie wird das richtig spannend ...

Rolf M. schrieb:
> Eric B. schrieb:
>> Hier hast du vll einen Überlauf, wenn *p == \000.
>
> Warum? Wenn *p == '\0', dann gibt iusspace(*p) 0 zurück (schließlich ist
> '\0' kein Space), und der if-Zweig wird gar nicht erst angesprungen.

Nicht beim if, sondern in der for-schleife; da wird nicht mehr auf 0 
getestet.

Rolf M. schrieb:
>> char *p = P;
>
> Da ist das unsigned verloren gegangen.

"left as excercise for the reader" ;-P

isspace( *p) durch *p == ' ' ersetzt, keine Änderung

Eigentlich kann man das eindampfen auf:

1

char *scword(unsigned char *p) {

2

  for ( ; *p && !isspace(*p); p++) ;

3

  for ( ; *p &&  isspace(*p); p++) ;

4

  return p;

5

}

Eric B. schrieb:
> Rolf M. schrieb:
>> Eric B. schrieb:
>>> Hier hast du vll einen Überlauf, wenn *p == \000.
>>
>> Warum? Wenn *p == '\0', dann gibt iusspace(*p) 0 zurück (schließlich ist
>> '\0' kein Space), und der if-Zweig wird gar nicht erst angesprungen.
>
> Nicht beim if, sondern in der for-schleife; da wird nicht mehr auf 0
> getestet.

Da gilt das gleiche wie für das if. Die Schleife bricht ab, sobald das 
Zeichen kein Space ist, also auch beim '\0'.

foobar schrieb:
> Allerdings sind in deinem Programm mind drei Fehler drin.

Ich hätt noch einen:
Wenn der String, der nach name oder workspace geschrieben wird, mal 
länger als 255 Zeichen sein sollte, gibt's einen Buffer Overflow. Ich 
würde dem sscanf_Formatstring noch die maximale Länge mitteilen.

Joachim D. schrieb:
> Mit Watcom kompiliert: Laufzeit 100 msec
> Mit GNU kompiliert: Laufzeit 17 sec (!)

Wie lange braucht dein Programm auf GNU, wenn in main() nichts 
drinsteht? Nicht dass da bloss die Startzeit eines leeren Programms in 
einer verhunzten Umgebung gemessen wird.