🚀 go-pugleaf

Jens Ehlers (Ehlers@tu-harburg.d400.de) wrote:

> Bei einem von mir geschriebenen Programm bekamm ich zur laufzeit 
> die Meldung:

>   Speicherzuordnugsfehler
>   COMMAND kann nicht geladen werden, System angehalten

> Ich habe das Programm schrittweise verkleinert, um den Fehler einzugrenzen, 
> was mich viele Stunden Arbeit gekostet hat.
> Die for Schleife hat den Zweck den Fehler sicherer zu bemerken.
> Das Programmfragment (s. unten) enth"alt mit hoher Sicherheit keinen Fehler.
> Ich habe es auf drei verschiedene Unix Workstations (Apollo, HP 700, IBM)
> "ubertragen. Auf allen drei Rechnertypen l"auft das Programm problemlos.
> Das Syntaxanalysewerkzeug {\tt lint} endeckt keine Fehler.
> Das Laufzeitanalysesystem Insight (IBM/AIX)  hat keine
> Speicherbereichs"uberschreitungen oder andere Fehler festgestellt:
> ...
> Mit Borland C++ 3.1 bekomme ich jedoch weiterhin den Laufzeitfehler,
> allerdings nur wenn ich das Speichermodell Large benutze.

> Meine Frage/Bitte:
>   - Ist die Speicherverwaltung von Borland C++ fehlerhaft?

Jein. Im Gegensatz zu Deinen C-Compilern auf den Unix-Workstations
(welche garantiert alle 32-bittig sind), ist Borland C 3.1 nur
16-bittig. Ob man das als Fehler ansehen will, bleibt wohl jedem
selbst ueberlassen. In der Praxis heisst das i. W.: kein "malloc" mit
mehr als 64 KB!

> ...

> #include<stdlib.h>
> #include<stdio.h>

> #define FREE(ptr) if (ptr) {free(ptr);ptr=NULL;}
> #define ANZ 20000

> int  main(int argc, char *argv[]);
> void fehler2 (char *funktion, char *text);
> void messe(int cfg[ANZ]);

> /*************************************************************/
> int main(int argc, char *argv[]){
> int cfg[ANZ];
> messe(cfg);
> return 0;}
> /*************************************************************/
> void messe(int cfg[ANZ]){
> short *werte_b=NULL;   /* Basis des Speicherbereichs  */
> float *ptr2=NULL;
> unsigned *dauer=NULL;
> unsigned long  werte_n;
> unsigned long n_zeiten;
> int n_kanaele=2;

> for (n_zeiten=100;n_zeiten<=40000;n_zeiten+=100){
> printf("**************************\nn-zeiten= %f\n",1.0*n_zeiten);
> werte_n  = (n_zeiten*n_kanaele   )*sizeof(short);

> /* Speicher anfordern */
> printf("werte_n=%lu\n",werte_n);
> werte_b   = (short *) malloc(werte_n);

> ...

Hier haben wir es ja: n_zeiten=40000, n_kanaele=2, sizeof(short)=2, gibt
werte_n=160000, also deutlich zuviel fuer das malloc.

Tip von mir: besorg Dir GNU-C/C++, dann hast Du solche Probleme nicht.


- Michael -
--
***************************************************************************
*   Michael Strauch            *  email:                                  *
*   University of Dortmund     *  strauch@emmy.mathematik.uni-dortmund.de *
*   Department of Mathematics  *                                          *
***************************************************************************

In article <43otte$ndb@rztsun.tu-harburg.de> Jens Ehlers <Ehlers@tu-harburg.d400.de> writes:
>Mit Borland C++ 3.1 bekomme ich jedoch weiterhin den Laufzeitfehler,
>allerdings nur wenn ich das Speichermodell Large benutze.

>Das Programm:

Nebenbemerkung: in Programmierkursen gaebs fuer solche Programme
Punktabzug wegen Unuebersichtlichkeit.

> [...]
> short *werte_b=NULL;   /* Basis des Speicherbereichs  */
> [...]
>for (n_zeiten=100;n_zeiten<=40000;n_zeiten+=100){
>werte_n  = (n_zeiten*n_kanaele   )*sizeof(short);
> werte_b   = (short *) malloc(werte_n);

Du forderst hier Felder von mehr als 64 KByte an, womit du gute
Chancen hast, das malloc() zu ueberfordern (es gibt dir dann einfach
werte_n % 65536 Bytes).
Selbst wenn das malloc() mitmacht, ist im Large-Speichermodell meiner
Erfahrung nach der Feldindexbereich auf 64 KByte begrenzt.

So oder so schreibst du ausserhalb der allokierten Speicherbereiche
und zerstoerst so die Speicherverwaltung des DOS.

Speichermodell Huge (oder explizites Arbeiten mit far und huge
Pointern) sollte abhelfen.
-- 
Lars Duening; duening@ibr.cs.tu-bs.de

Michael Strauch (strauch@emmy.mathematik.uni-dortmund.de) wrote:
: Jens Ehlers (Ehlers@tu-harburg.d400.de) wrote:

: > Bei einem von mir geschriebenen Programm bekamm ich zur laufzeit 
: > die Meldung:

: >   Speicherzuordnugsfehler
: >   COMMAND kann nicht geladen werden, System angehalten
[ DEL: Bsp-Programm ]

: Jein. Im Gegensatz zu Deinen C-Compilern auf den Unix-Workstations
: (welche garantiert alle 32-bittig sind), ist Borland C 3.1 nur
: 16-bittig. Ob man das als Fehler ansehen will, bleibt wohl jedem
: selbst ueberlassen. In der Praxis heisst das i. W.: kein "malloc" mit
: mehr als 64 KB!

: Hier haben wir es ja: n_zeiten=40000, n_kanaele=2, sizeof(short)=2, gibt
: werte_n=160000, also deutlich zuviel fuer das malloc.

: Tip von mir: besorg Dir GNU-C/C++, dann hast Du solche Probleme nicht.

: - Michael -

Oder nimm farmalloc/farfree. Damit kann man auch Bloecke >64K belegen.
Aber man immer noch nur 64K-Bloecke bearbeiten. Eine Loesung waere,
die entsprechenden Pointer als huge zu deklarieren; dann normalisiert das
Laufzeitsystem die Pointer beim Benutzen.

Aber falls du auf die Borland-IDE verzichten kannst, solltest du doch,
wie von Michael vorgeschlagen, einen GNU-C/C++-Compiler benutzen, wie
z.B. den djgpp. Das Laufzeitsystem (bzw. der dazugehoerende DOS-Extender)
stellt deinem Programm sogar virtuellen Speicher zur Verfuegung.

  Reinhard.
--
 /-- Reinhard Pfau --- (ED-Pfau) --------------------------------------------\
| eMail: gz342@appl2.hrz.uni-siegen.de  |  IRC: Mubo  | no home-page         |
+----------------------------------------------------------------------------+
  "Programming is: Force the computer to do what _YOU_ want."  (rp)
  "Using M$-ware is the opposite!" 

duening@ibr.cs.tu-bs.de (Lars Duening) wrote:
>Nebenbemerkung: in Programmierkursen gaebs fuer solche Programme
>Punktabzug wegen Unuebersichtlichkeit.

Die Quelle ist nur ein kleiner Rest eines urspruenglich laengeren Programms. 
Das Programm ist noch viel viel unuebersichtlicher. 


>
>> [...]
>> short *werte_b=NULL;   /* Basis des Speicherbereichs  */
>> [...]
>>for (n_zeiten=100;n_zeiten<=40000;n_zeiten+=100){
>>werte_n  = (n_zeiten*n_kanaele   )*sizeof(short);
>> werte_b   = (short *) malloc(werte_n);
>
>Du forderst hier Felder von mehr als 64 KByte an, womit du gute
>Chancen hast, das malloc() zu ueberfordern (es gibt dir dann einfach
>werte_n % 65536 Bytes).

Normalerweise muss malloc() NULL zurueckgeben wenn es ueberfordert ist.
Wenn durch die Konversion in den size_t der Zahlenwert geaendert wird bekomme ich
eben weniger Speicher (s. o.).

>Selbst wenn das malloc() mitmacht, ist im Large-Speichermodell meiner
>Erfahrung nach der Feldindexbereich auf 64 KByte begrenzt.
>
>So oder so schreibst du ausserhalb der allokierten Speicherbereiche
>und zerstoerst so die Speicherverwaltung des DOS.

Ich schreibe nicht in und ich lese nicht aus dem Bereich!
Ich allokiere und gebe danach frei. 
Das sollte in jedem Fall (auch mit DOS auf PC) funktionieren.
Oder nicht?

>
>Speichermodell Huge (oder explizites Arbeiten mit far und huge
>Pointern) sollte abhelfen.

In dem urspruenglichen Programm habe ich huge Pointer, faralloc() und farfree() 
benutzt. Das Problem ist das gleiche. Ich hatte alle PC/Borland C++ spezifischen
Elemente entfernt um auch auf anderen Maschinen (HP 7xx, Apollo, IBM/AIX) 
nach dem Fehler zu suchen. Das Problem tritt nur mit
Borland C++ auf.


Die Frage bleibt: Was ist falsch? Das Programm? Der Compiler? Der PC?

Jens

-- 
Jens Ehlers   Hamburg, Germany
    Tel.  : +49 (0) 40 /  77 18 - 23 57 
    Fax.  : +49 (0) 40 /  77 18 - 20 28
    E-Mail: Ehlers@tu-harburg.d400.de

strauch@emmy.mathematik.uni-dortmund.de (Michael Strauch) wrote:
>Jens Ehlers (Ehlers@tu-harburg.d400.de) wrote:


>
>> Meine Frage/Bitte:
>>   - Ist die Speicherverwaltung von Borland C++ fehlerhaft?
>
>Jein. Im Gegensatz zu Deinen C-Compilern auf den Unix-Workstations
>(welche garantiert alle 32-bittig sind), ist Borland C 3.1 nur
>16-bittig. Ob man das als Fehler ansehen will, bleibt wohl jedem
>selbst ueberlassen. In der Praxis heisst das i. W.: kein "malloc" mit
>mehr als 64 KB!

Ich wuerde zu Ja tendieren. Wenn ich von malloc() "zu viel" (Ich brauche
fuer die urspruengliche Aufgabe etwa 200k. Das find ich recht wenig.)
verlange, sollte es NULL zuruechgeben und nicht den PC "absaufen" 
lassen.
 

>> werte_b   = (short *) malloc(werte_n);
>
>Hier haben wir es ja: n_zeiten=40000, n_kanaele=2, sizeof(short)=2, gibt
>werte_n=160000, also deutlich zuviel fuer das malloc.

s. o 



>
>Tip von mir: besorg Dir GNU-C/C++, dann hast Du solche Probleme nicht.
>
Ich brauche den PC fuer einen Versuch zum Messen und Regeln.
Die Treibersoftware fuer die A/D Karte ist in C fuer BC und MS C 
geschrieben. Ich fuerchte mit einem anderen (sicherlich besseren)
Compiler bekomme ich Probleme mit der Treibersoftware. Wenn es 
geht, moechte ich diese nicht portieren oder neu schreiben.

Jens

-- 
Jens Ehlers   Hamburg, Germany
    Tel.  : +49 (0) 40 /  77 18 - 23 57 
    Fax.  : +49 (0) 40 /  77 18 - 20 28
    E-Mail: Ehlers@tu-harburg.d400.de

gz342@appl2.hrz.uni-siegen.de (Reinhard Pfau) wrote:
>Michael Strauch (strauch@emmy.mathematik.uni-dortmund.de) wrote:
>: Jens Ehlers (Ehlers@tu-harburg.d400.de) wrote:
>
>: > Bei einem von mir geschriebenen Programm bekamm ich zur laufzeit 
>: > die Meldung:
>
>: >   Speicherzuordnugsfehler
>: >   COMMAND kann nicht geladen werden, System angehalten

>Oder nimm farmalloc/farfree. Damit kann man auch Bloecke >64K belegen.
>Aber man immer noch nur 64K-Bloecke bearbeiten. Eine Loesung waere,
>die entsprechenden Pointer als huge zu deklarieren; dann normalisiert das
>Laufzeitsystem die Pointer beim Benutzen.

Habe ich alles Probiert. Da ich etwa 200k brauche und Pointerarithmetik
benutzen moechte habe ich huge Pointer farmalloc() und farfree() benutzt.
Der Fehler bleibt. Ausserdem egal welche Menge ich _anfordere_ (kein Zugriff)
malloc() muesste NULL zurueckliefern, das Programm normal enden.
Ich bekomme NULL (schon bei etwa 16k) und 
       Speicherzuordnugsfehler
       COMMAND kann nicht geladen werden, System angehalten
                                          XXXXXXXXXXXXXXXXX

>: Tip von mir: besorg Dir GNU-C/C++, dann hast Du solche Probleme nicht.
>
>: - Michael -
>

>Aber falls du auf die Borland-IDE verzichten kannst, solltest du doch,
>wie von Michael vorgeschlagen, einen GNU-C/C++-Compiler benutzen, wie
>z.B. den djgpp. Das Laufzeitsystem (bzw. der dazugehoerende DOS-Extender)
>stellt deinem Programm sogar virtuellen Speicher zur Verfuegung.
>
>  Reinhard.

Die Umgebung ist nicht das Problem. Ich moechte mit dem PC Messen, Steuern und Regeln.
Der PC hat eine A/D Karte deren Treiber in Borland C und MS C geschrieben ist.
Wenn es geht moechte ich den Kartentreiber weder Portieren noch Neuschreiben.


Gruss  

Jens
-- 
Jens Ehlers,   Hamburg, Germany
 Tel.: +49 (0) 40 /  77 18 - 23 57   (privat: +49 (0) 40 /  7 20 94 07)
 Fax.: +49 (0) 40 /  77 18 - 20 28   E-Mail: Ehlers@tu-harburg.d400.de

In article <43r2q6$850@rztsun.tu-harburg.de> Jens Ehlers <Ehlers@tu-harburg.d400.de> writes:
>duening@ibr.cs.tu-bs.de (Lars Duening) wrote:
>>> [...]
>>> short *werte_b=NULL;   /* Basis des Speicherbereichs  */
>>> [...]
>>>for (n_zeiten=100;n_zeiten<=40000;n_zeiten+=100){
>>>werte_n  = (n_zeiten*n_kanaele   )*sizeof(short);
>>> werte_b   = (short *) malloc(werte_n);
>>
>>Du forderst hier Felder von mehr als 64 KByte an, womit du gute
>>Chancen hast, das malloc() zu ueberfordern (es gibt dir dann einfach
>>werte_n % 65536 Bytes).
>
> Normalerweise muss malloc() NULL zurueckgeben wenn es ueberfordert ist.

Nur wenn nicht genug Speicher frei ist. Von einer
long->short-Konversion merkt es ja nichts.

>>So oder so schreibst du ausserhalb der allokierten Speicherbereiche
>>und zerstoerst so die Speicherverwaltung des DOS.
>
> Ich schreibe nicht in und ich lese nicht aus dem Bereich!
> Ich allokiere und gebe danach frei. 
> Das sollte in jedem Fall (auch mit DOS auf PC) funktionieren.
> Oder nicht?

Hmm, knifflig.
Reduzier das Programm weiter (Funktionsargumente weg, lokale Variablen
weg, ...), bis der Fehler nicht mehr auftritt.
Im wievielten Schleifendurchlauf bei welchem malloc() tritt der Fehler
eigentlich auf?
-- 
Lars Duening; duening@ibr.cs.tu-bs.de

Jens Ehlers <Ehlers@tu-harburg.d400.de> writes:

>Ich habe ein Problem.
>Bei einem von mir geschriebenen Programm bekamm ich zur laufzeit 
>die Meldung:

>  Speicherzuordnugsfehler
>  COMMAND kann nicht geladen werden, System angehalten

[...]

Ueber die verschieden groessen Pointer, Speichermodelle und mallocs() und
dass Du glaubst, dass Du da alles richtig machst, hast Du geschrieben. (Und
alles gehoert nicht nach d.c.l.c :-| )

Ich habe zwar kein BC 3.1, schlage aber vor:

[...] 

>werte_b   = (short *) malloc(werte_n);
>dauer = (unsigned int *) malloc(sizeof(unsigned int)*n_zeiten);

[...]

>/* Speicher freigeben */
>FREE(werte_b);
>FREE(dauer);

Vertausche doch mal die beiden FREEs.

b.
-- 
                                                        __o
                                                      _`\<,_
                                                     (_)/ (_)
-------------------------------------------------------------
Andreas Burmester                  Internet: buster@isys.net
Phn & FAX: +49 40 6900337
-------------------------------------------------------------

Hallo Jens,
der Fehler in Deinem Programm tritt bei mir nur auf, wenn ich als Floating  
Point Option in der IDE "80287/387" aktiviere. Setze ich die Option auf  
"Emulation", läuft das Programm fehlerfrei durch.

Testkonfiguration: 486DX33, BC++ 3.1, Speichermodell Large.

Für eine genauere Fehleranalyse habe ich im Moment keine Zeit, aber  
vielleicht hilfts auch so.

Gruß Ruediger
--

## CrossPoint v3.02 R ##