Ringpufferspeicher

[Hans W. (Firma: NiX) (vipar)]

Hi Leute!

Wir haben heute in der Vorlesung Programmschnipsel zu einem 
Ringpufferspeicher (Bounded Buffer Problem in Bezug auf das 
Producer-Consumer-Konzept) in C durchgenommen. Ich hab da mal so richtig 
gar nix verstanden was wohl daran liegt, weil mir das Konzept eines 
Ringpufferspeichers nix gesagt hat.

Im Internet hab ich dazu auch nicht wirklich was gefunden. Vielleicht 
könnte mir jemand den Ringpufferspeicher kurz erklären, damit ich das 
Codebeispiel besser verstehen kann?


Frage: Soll ich das Code-Beispiel mal posten?


Danke für eure Hilfe!

[Martin S. (sirnails)]

Code wäre nicht schlecht.

[Hans W. (Firma: NiX) (vipar)]

Hier das Code-Beispiel an dem wir das durch exerziert haben:

/*Insert()-Methode*/

while(true)
{
while(((in+1) % BUFFER_SIZE) == out);
buffer[in] = next_Produced;
in = (in+1) % BUFFER_SIZE;
}



while(true)
/*Remove()-Methode*/

while(true)
{
while(in == out);
next_Consumed = buffer[out];
out = (out+1) % BUFFER_SIZE;

return next_Consumed;
}

[Hans W. (Firma: NiX) (vipar)]

Bei dem oben gezeigtn Code-Beispielen frage ich mich schon die ganze 
Zeit, ob man die zwei Methoden, also Remove() und Insert() parallel 
(z.B. verteilt auf zwei Prozesse) oder nacheinander betrachten muss (so 
wie ich es bisher immer gemacht habe)?

[codehamster (Gast)]

bin etwas im schuss, desshalb mal kurz einen Link, hast du das schon mal 
durchgelesen? Ev. hilfts was fürs Verständnis.

http://www.mikrocontroller.net/articles/FIFO

[HolgerT (Gast)]

Konzept Ringbuffer:
http://www.mikrocontroller.net/articles/FIFO

Wichtig sind die zwei Zeiger: Schreibzeiger und Lesezeiger. Wie der Name 
schon sagt: Auf die Speicherzelle Schreibzeiger+1 wird geschrieben, von 
dort wo der Lesezeiger hinzeigt wird gelesen. Dazu ein 
Increment-Management für beide Zeiger und fertig ist der Ringbuffer.

Bei Schreibzeiger=Lesezeiger ist der Buffer leer.

[Hans W. (Firma: NiX) (vipar)]

Danke!!

Werd ich mir durchlesen. Vielleicht kannst du mir eine Frage 
beantworten:

-> Für mich machen die zwei Code-Schnipsel nur Sinn, wenn man sie 
parallel betrachtet. Ist das richtig?

[Karl H. (kbuchegg)]

Hans Wurst schrieb:

> -> Für mich machen die zwei Code-Schnipsel nur Sinn, wenn man sie
> parallel betrachtet. Ist das richtig?


Das kann man durchaus so sagen. So wie diese Schnipsel gestaltet sind, 
findet man das in der Praxis nicht. Die while Schleifen sollen wohl 
sowas wie 'Prozesse' andeuten.

[Karl H. (kbuchegg)]

> Ich hab da mal so richtig gar nix verstanden was wohl daran liegt, weil
> mir das Konzept eines Ringpufferspeichers nix gesagt hat.

Ist doch ganz simpel.

Stell dir eine Uhr vor. An jeder Position des Sekundenzeigers kannst du 
einen Wert ablegen. Jedesmal wenn du einen Wert ablegst, rückt der 
Zeiger 1 weiter.

Iregendwann ist der Zeiger rundum und (wenn du die Daten nicht abholst) 
werden die ältesten Informationen überschrieben.

Zum auslesen der Daten gibt es einen 2-ten Zeiger. Der sagt dir, welcher 
Wert der nächste zu liefernde ist, wenn Auslesen angesagt ist. Der rückt 
nach jedem Auslesen um 1 weiter.

Gemeinsam laufen die Zeiger immer im Kreis rum: Wird ein Wert eingefügt, 
dann dort wo der erste Zeiger hinzeigt, der dann 1 weiter gestellt wird. 
Wird ein Wert ausgelesen, dann wird der Wert von dort geholt, wo der 
2.te Zeiger hinzeigt und der um 1 weiter gestellt.

Die Speicherfläche ist zu einem Kreis 'gebogen' worden. Daher 
"Ring"-Buffer.

[Hans W. (Firma: NiX) (vipar)]

Karl Heinz Buchegger schrieb:
> Das kann man durchaus so sagen. So wie diese Schnipsel gestaltet sind,
> findet man das in der Praxis nicht. Die while Schleifen sollen wohl
> sowas wie 'Prozesse' andeuten.


Hm, ob man das in der Praxis so findet is unseren Prof. dann wohl egal; 
leider...

Naja, jedenfalls bin ich schon auf der richtigen Fährte wenn ich in 
jedem Schritt beide Schnipsel gleichzeitig betrachte, oder?

Wenn nun in = 0 und out = 0:

insert-Methode:

-Argument der while-Schleife wird ungleich Inhalt von out -> aktives 
warten wird unterbrochen.
-
in buffer[0] wird next_Produced geschrieben

-in wird auf in=1 geändert


remove-Methode:

- wartet die ganze Zeit über in der Schleife weil ja, so lange in in der 
insert-Methode nicht geändert wird, das Schleifenargument "richtig" ist. 
Ab dem Zeitpunkt wo das Argument der remove-Methode-while-Schleife 
"falsch" wird hohlt die remove-Methode den geschriebenen Wert von 
buffer[0] nach next_Consumed. Danach wird out auf out=1 erhöht und der 
jeweilige wert mit return zurückgegeben.

Dann geht das Spielchen wieder von vorne los. Jetzt ist in=1 und out=1 
und in der inneren while-Schleife der insert-Methode wird diese "falsch" 
und in buffer[] wird wieder geschrieben usw usf...



Richtig so?

[Karl H. (kbuchegg)]

> -Argument der while-Schleife wird ungleich Inhalt von
> out -> aktives warten wird unterbrochen.

Diese while-Schleife hat nicht die Aufgabe in erster Linie 'aktiv zu 
warten', sondern darauf zu warten, dass der Ringbuffer aus seiner 'Ich 
bin voll' Situation herausgebracht wird.

D.h. der Sendeprozess füllt den Ringbuffer durch die darüberliegende 
while Schleife(die so nicht realistisch ist) randvoll an (während der 
Leseprozess 'gleichzeitig' ausliest, aber nicht hinterherkommt). 
Irgendwann ist der Buffer voll und dadurch verfängt sich der 
Sendeprozess in der
  while(((in+1) % BUFFER_SIZE) == out);
Schleife und wartet so diese Fehlersituation ab.

  while(((in+1) % BUFFER_SIZE) == out)  // ist der Ringbuffer voll?
    ;                                   // ja: warten

  buffer[in] = next_Produced;           // Im RB ist Platz, Daten einstellen
  in = (in+1) % BUFFER_SIZE;