Ich möchte unserer Internetleitung eine Art Verkehrsmanagement hinzufügen. Nachdem ich viel Dokumentation gelesen habe, denke ich, dass HFSC zu kompliziert für mich ist (ich verstehe nicht alle Kurven, ich fürchte, ich werde es nie richtig machen), CBQ wird nicht empfohlen, und im Grunde ist HTB der Weg dazu gehen für die meisten Menschen.
Unser internes Netzwerk besteht aus drei "Segmenten", und ich möchte die Bandbreite (zumindest zu Beginn) mehr oder weniger gleichmäßig auf diese verteilen. Außerdem muss ich den Verkehr nach mindestens drei Arten von Verkehr priorisieren (Echtzeitverkehr, Standardverkehr und Massenverkehr). Die gemeinsame Nutzung der Bandbreite ist nicht so wichtig wie die Tatsache, dass Echtzeitverkehr nach Möglichkeit immer als Premiumverkehr behandelt werden sollte, aber natürlich darf auch keine andere Verkehrsklasse verhungern.
Die Frage ist, was sinnvoller ist und auch einen besseren Echtzeitdurchsatz garantiert:
Erstellen einer Klasse pro Segment mit jeweils derselben Rate (Priorität spielt laut HTB-Entwickler keine Rolle für Klassen, die keine Blätter sind), und jede dieser Klassen verfügt über drei Unterklassen (Blätter) für die drei Prioritätsstufen (mit unterschiedlichen Prioritäten) und unterschiedliche Preise).
Eine Klasse pro Prioritätsstufe an der Spitze, jede mit einer anderen Rate (wiederum spielt die Priorität keine Rolle) und jede mit 3 Unterklassen, eine pro Segment, während alle 3 in der Echtzeitklasse das höchste Prio und das niedrigste Prio in der Masse haben Klasse und so weiter.
Ich werde versuchen, dies mit dem folgenden ASCII-Kunstbild klarer zu machen:
Case 1:
root --+--> Segment A
| +--> High Prio
| +--> Normal Prio
| +--> Low Prio
|
+--> Segment B
| +--> High Prio
| +--> Normal Prio
| +--> Low Prio
|
+--> Segment C
+--> High Prio
+--> Normal Prio
+--> Low Prio
Case 2:
root --+--> High Prio
| +--> Segment A
| +--> Segment B
| +--> Segment C
|
+--> Normal Prio
| +--> Segment A
| +--> Segment B
| +--> Segment C
|
+--> Low Prio
+--> Segment A
+--> Segment B
+--> Segment C
Fall 1 Scheint so, wie es die meisten Leute tun würden, aber wenn ich die Details der HTB-Implementierung nicht richtig lese, bietet Fall 2 möglicherweise eine bessere Priorisierung.
Das HTB-Handbuch besagt, dass eine Klasse, wenn sie ihre Rate erreicht hat, möglicherweise von ihrem Elternteil leiht. Beim Ausleihen erhalten Klassen mit höherer Priorität immer zuerst die angebotene Bandbreite. Es heißt jedoch auch, dass Klassen mit Bandbreite auf einer niedrigeren Baumebene unabhängig von der Priorität immer Klassen auf einer höheren Baumebene vorgezogen werden .
Nehmen wir die folgende Situation an: Segment C sendet keinen Verkehr. Segment A sendet nur Echtzeitverkehr, so schnell es geht (genug, um die Verbindung alleine zu sättigen), und Segment B sendet nur Massenverkehr, so schnell es geht (wieder genug, um die gesamte Verbindung alleine zu sättigen). Was wird passieren?
Fall 1:
Segment A-> High Prio und Segment B-> Low Prio müssen beide Pakete senden, da A-> High Prio die höhere Priorität hat, wird es immer zuerst geplant, bis es seine Rate erreicht. Jetzt wird versucht, Kredite von Segment A aufzunehmen. Da sich Segment A jedoch auf einem höheren Niveau befindet und Segment B-> Low Prio seinen Zinssatz noch nicht erreicht hat, wird diese Klasse jetzt zuerst bedient, bis sie auch den Zinssatz erreicht und Kredite aufnehmen möchte Segment B. Sobald beide ihre Raten erreicht haben, sind beide wieder auf dem gleichen Niveau und jetzt wird Segment A-> High Prio wieder gewinnen, bis es die Rate von Segment A erreicht. Jetzt versucht es, Kredite von der Wurzel aufzunehmen (die hat viel Verkehr übrig, da Segment C keinen seiner garantierten Datenverkehr verwendet), aber es muss erneut warten, bis Segment B-> Low Prio auch die Root-Ebene erreicht. Sobald das passiert,
Fall 2:
High Prio-> Segment A und Low Prio-> Segment B haben beide Pakete zu senden, wieder wird High Prio-> Segment A gewinnen, da es die höhere Priorität hat. Sobald es seine Rate erreicht hat, versucht es, Kredite von High Prio aufzunehmen, das über eine freie Bandbreite verfügt. Da es sich jedoch auf einem höheren Niveau befindet, muss es warten, bis Low Prio-> Segment B erneut seine Rate erreicht. Sobald beide ihre Rate erreicht haben und beide Kredite aufnehmen müssen, gewinnt High Prio-> Segment A erneut, bis es die Rate der High Prio-Klasse erreicht. Sobald dies geschieht, versucht es, sich von root auszuleihen, das wieder genügend Bandbreite hat (die gesamte Bandbreite von Normal Prio wird derzeit nicht verwendet), muss jedoch erneut warten, bis Low Prio-> Segment B das Ratenlimit von erreicht Niedrige Prio-Klasse und versucht auch, von root zu leihen. Schließlich versuchen beide Klassen, sich von root zu leihen, wobei die Priorität berücksichtigt wird und High Prio->
Beide Fälle scheinen nicht optimal zu sein, da der Echtzeitverkehr manchmal auf Massenverkehr warten muss, obwohl noch genügend Bandbreite vorhanden ist, die er ausleihen könnte. In Fall 2 scheint der Echtzeitverkehr jedoch weniger warten zu müssen als in Fall 1, da er nur warten muss, bis die Massenverkehrsrate erreicht ist, die höchstwahrscheinlich geringer ist als die Rate eines ganzen Segments (und in diesem Fall) 1 das ist die Rate, auf die gewartet werden muss). Oder irre ich mich hier total?
Ich dachte über noch einfachere Setups nach, bei denen eine vorrangige qdisc verwendet wurde. Prioritätswarteschlangen haben jedoch das große Problem, dass sie Hunger verursachen, wenn sie nicht irgendwie eingeschränkt sind. Hunger ist nicht akzeptabel. Natürlich kann man in jede Prioritätsklasse einen TBF (Token Bucket Filter) einfügen, um die Rate zu begrenzen und so Hunger zu vermeiden. Dabei kann eine einzelne Prioritätsklasse die Verbindung nicht mehr alleine sättigen, selbst wenn alle anderen Prioritätsklassen leer sind, verhindert die TBF dies. Und das ist auch nicht optimal, denn warum würde eine Klasse nicht 100% der Bandbreite der Leitung erhalten, wenn im Moment keine andere Klasse etwas davon benötigt?
Irgendwelche Kommentare oder Ideen zu diesem Setup? Es scheint so schwer zu sein, Standard-TC-QDiscs zu verwenden. Als Programmierer war es eine so einfache Aufgabe, wenn ich einfach meinen eigenen Scheduler schreiben konnte (was ich nicht darf).