verschachtelte Warteschleifen in C und Assembler

[Stefan F. (stefanf)]

Hallo zusammen,

ich bereite mich gerade auf eine Klausur vor. Eine Vorbereitungsaufgabe 
lautet:

Entwerfen Sie in C und Assembler eine 3-fach verschachtelte 
Warteschleife.

Mein Ansatz sieht so aus:

C:

int zaehl1 = 0;
int zaehl2 = 0;
int zaehl3 = 0;

while (zaehl1 = 0; zaehl1 < 1000; zaehl1++)
{
   while (zaehl2 = 0; zaehl2 < 1000; zaehl2++)
   {
      while (zaehl3 = 0; zaehl3 < 1000; zaehl3++)
   }
}

Assembler:

push cx
mov cx, 0FFFh

waitloop1:

loop waitloop1
mov cx, 0FFFh

waitloop2:

loop waitloop2
mov cx, 0FFFh

waitloop3:
loop waitloop3
pop cx


Funktioniert das so?
Ich bin noch relativ neu in der Programmierung und hoffe, dass ich nicht 
allzu großen Mist zusammengeschrieben hab. Vielen Dank schonmal im 
Voraus.

[Stefan E. (sternst)]

Stefan F. schrieb:
> C:

1) Du hast "while" und "for" verwechselt.
2) Das fehlt entweder noch ein Klammerpaar, oder ein Semikolon (je nach 
persönlichem Geschmack).

Stefan F. schrieb:
> Assembler:

Das ist keine 3-fach verschachtelte Schleife, sondern einfach nur 3 
Schleifen hintereinander.

[Stefan F. (stefanf)]

Und wie geht es richtig?

[der mechatroniker (Gast)]

Im C-Programm fehlt noch das asm volatile ("nop") in der inneren 
Schleife, sonst macht das Programm einfach gar nichts.

[Stefan E. (sternst)]

Stefan F. schrieb:
> Und wie geht es richtig?

Du hast doch schon eine verschachtelte Schleife in C gemacht (jedenfalls 
vom Prinzip her). Mach das gleich in Assembler.

[Stefan F. (stefanf)]

Vielleicht so?

C:

for (zaehl1 = 0; zaehl1 < 1000; zaehl1++)
{
   for (zaehl2 = 0; zaehl2 < 1000; zaehl2++)
   {
      for (zaehl3 = 0; zaehl3 < 1000; zaehl3++)
      {
         _NOP();
      }
   }
}

In Assembler komm ich irgendwie mit der Verschachtelung nicht klar. Muss 
ich da Jump-Befehle verwenden?

[fh bncvx (Gast)]

Du musst sie verschachteln.

[Stefan F. (stefanf)]

push cx

mov cx, 0FFFh
waitloop1:
push cx

mov cx, 0FFFh
waitloop2:
push cx

mov cx, 0FFFh
waitloop3:
push cx

pop cx
loop waitloop3

pop cx
loop waitloop2

pop cx
loop waitloop3




So besser?

[Floh (Gast)]

Stefan F. schrieb:
 push cx
 mov cx, 0FFFh
 waitloop1:

   push cx
   mov cx, 0FFFh
   waitloop2:

     push cx
     mov cx, 0FFFh
     waitloop3:
     loop waitloop3
     pop cx

   loop waitloop2
   pop cx

 loop waitloop1
 pop cx

Versuch ohne Gewähr :-)

[Stefan F. (stefanf)]

Ich dachte mir, dass das durch das Sichern und wieder Laden vom Stack so 
funktionieren könnte.

[Karl H. (kbuchegg)]

Stefan F. schrieb:
> Ich dachte mir, dass das durch das Sichern und wieder Laden vom Stack so
> funktionieren könnte.

Wenn in deiner Klausur viel Wert auf Assembler gelegt wird, dann 
solltest du in die Basiskonzepte noch mehr Zeit zur Vorbereitung legen.

Wenn Assembler erwartungsgemäß in deiner Klausur nur das Sahnehäubchen 
für die volle Punktzahl ist, dann lass es links liegen.

Mit so einer Aussage bei dieser Aufgabenstellung disqualifizierst du 
dich selber.

[Stefan F. (stefanf)]

Wir haben nur ein paar Befehle durchgenommen. Wir machen nicht wirklich 
Assembler. Es geht nur um das Grundverständnis.

[Karl H. (kbuchegg)]

Deine C Lösung sieht ja grundsätzlich nicht schlecht aus.

Du kannst mehr oder weniger auch in Assembler dasselbe machen:

  es ist auch in Assembler erst mal nicht verboten, die
  Schleifenstruktur (Anfang, Körper, Ende) durch Einrückungen
  sichtbar zu machen

  du kannst auch in Assembler mehrere Register benutzen. Dann brauchst
  du innerhalb der Schleifen gar nicht pushen/poppen

  Das pushen/poppen ist ja nur deswegen notwendig, weil in allen
  Schleifen immer das cx Register benutzt wird, und es daher in
  einer inneren Schleife gesichert werden muss, damit der aktuelle
  Zählwert der jeweils äusseren Schleife nicht verloren geht.

[Rolf Magnus (Gast)]

Wenn er auf das Sichern des CX-Registers verzichten soll, muß er dafür 
aber den loop-Befehl durch ein Dekrement und einen bedingten Sprung 
ersetzen, weil loop halt immer CX verwendet.

[Johannes K (Gast)]

Stand vor dem gleichen "Problem". Habs damit gelöst:


push cx

mov cx,1000
schleife0:
  push cx
  mov cx,1000

    schleife1:
      push cx
      mov cx,1000

        schleife2:
        loop schleife2

      pop cx
    loop schleife1
  pop cx
loop schleife0
pop cx


Also prinzipiell das Gleiche wie bei dir, hat auch funktioniert... Viel 
Erfolg morgen beim BGS. :-)

Johannes

[Stefan F. (stefanf)]

Hier werden sich jetzt alle fragen, warum man beim Bundesgrenzschutz 
Assembler lernt :P

[Paul Baumann (Gast)]

>Hier werden sich jetzt alle fragen, warum man beim Bundesgrenzschutz
>Assembler lernt :P

Dann kann man einen Grenzverletzer mit der mit jmp über den Zaun 
gekommen
ist, mit move wieder zurück schicken.

;-)
Push Paul