ฉันต้องการเพิ่มการจัดการปริมาณข้อมูลบางอย่างลงในสายอินเทอร์เน็ตของเรา หลังจากอ่านเอกสารจำนวนมากฉันคิดว่า HFSC ซับซ้อนเกินไปสำหรับฉัน (ฉันไม่เข้าใจทุกสิ่งที่โค้งฉันกลัวว่าฉันจะไม่ทำให้ถูกต้อง) CBQ ไม่แนะนำและโดยทั่วไป HTB เป็นวิธีการ ไปสำหรับคนส่วนใหญ่
เครือข่ายภายในของเรามี "กลุ่ม" สามส่วนและฉันต้องการแบ่งปันแบนด์วิดท์มากขึ้นหรือน้อยลงเท่ากันระหว่างกลุ่มเหล่านั้น (อย่างน้อยก็ในช่วงแรก) นอกจากนี้ฉันต้องจัดลำดับความสำคัญของการรับส่งข้อมูลตามการรับส่งข้อมูลอย่างน้อยสามประเภท (การจราจรตามเวลาจริงการจราจรมาตรฐานและการรับส่งข้อมูลจำนวนมาก) การแบนด์วิธร่วมกันไม่สำคัญเท่ากับความจริงที่ว่าการรับส่งข้อมูลแบบเรียลไทม์ควรจะถือว่าเป็นการรับส่งข้อมูลแบบพรีเมี่ยมเมื่อใดก็ตามที่เป็นไปได้ แต่แน่นอนว่าไม่มีคลาสการรับส่งข้อมูลอื่น ๆ
คำถามคืออะไรที่เหมาะสมกว่าและยังรับประกัน throughput ที่ดีขึ้น:
การสร้างหนึ่งคลาสต่อเซกเมนต์แต่ละคลาสมีอัตราเท่ากัน (ลำดับความสำคัญไม่สำคัญสำหรับคลาสที่ไม่มีใบตามนักพัฒนา HTB) และแต่ละคลาสเหล่านี้มีคลาสย่อยสามคลาส (ใบไม้) สำหรับระดับความสำคัญ 3 ระดับ (ที่มีลำดับความสำคัญต่างกัน และอัตราต่าง ๆ )
มีหนึ่งคลาสต่อระดับความสำคัญด้านบนแต่ละคนมีอัตราที่แตกต่างกัน (ลำดับความสำคัญอีกครั้งจะไม่สำคัญ) และแต่ละคนมี 3 คลาสย่อยหนึ่งต่อเซ็กเมนต์ในขณะที่ทั้ง 3 ในชั้นเรียลไทม์มี Prio สูงสุดต่ำสุดในกลุ่ม ชั้นเรียนและอื่น ๆ
ฉันจะพยายามทำให้ชัดเจนยิ่งขึ้นด้วยภาพศิลปะ ASCII ต่อไปนี้:
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
กรณีที่ 1 ดูเหมือนว่าคนส่วนใหญ่จะทำ แต่ถ้าฉันไม่ได้อ่านรายละเอียดการติดตั้ง HTB อย่างถูกต้องกรณีที่ 2 อาจให้ความสำคัญกับการจัดลำดับความสำคัญได้ดีกว่า
คู่มือ HTB กล่าวว่าหากชั้นเรียนได้รับผลกระทบอาจจะยืมจากผู้ปกครองและเมื่อยืมชั้นเรียนที่มีลำดับความสำคัญสูงกว่าจะได้รับแบนด์วิดท์ที่เสนอก่อนเสมอ แต่ก็ยังบอกว่าการเรียนที่มีแบนด์วิดธ์ที่มีอยู่บนต้นไม้ในระดับต่ำกว่าที่ต้องการเสมอกับผู้ที่อยู่ในระดับที่สูงขึ้นต้นไม้, โดยไม่คำนึงถึงความสำคัญ
สมมติว่าสถานการณ์ต่อไปนี้: เซกเมนต์ C ไม่ได้ส่งปริมาณข้อมูลใด ๆ กลุ่ม A ส่งการรับส่งข้อมูลแบบเรียลไทม์เร็วที่สุดเท่าที่จะทำได้ (เพียงพอที่จะเชื่อมโยงอย่างเดียว) และเซ็กเมนต์ B กำลังส่งปริมาณการเข้าชมจำนวนมากเท่านั้นให้เร็วที่สุดเท่าที่จะทำได้ (อีกครั้ง อะไรจะเกิดขึ้น?
กรณีที่ 1:
เซกเมนต์ A-> High Prio และ Segment B-> Low Prio ทั้งคู่มีแพ็กเก็ตที่จะส่งเนื่องจาก A-> High Prio มีลำดับความสำคัญสูงกว่าจะมีการกำหนดเวลาไว้ก่อนเสมอจนกว่าจะถึงอัตราของมัน ตอนนี้มันพยายามกู้เงินจากเซกเมนต์ A แต่เนื่องจากเซกเมนต์ A อยู่ในระดับที่สูงขึ้นและเซกเมนต์ B-> Low Prio ยังไม่ได้รับผลกระทบอัตรานี้ชั้นนี้จะให้บริการก่อนจนกว่าจะถึงอัตราและต้องการยืมจาก เซกเมนต์บีเมื่อทั้งคู่ได้รับอัตราของพวกเขาทั้งสองอยู่ในระดับเดียวกันอีกครั้งและตอนนี้เซกเมนต์ A-> High Prio จะชนะอีกครั้งจนกว่าจะถึงอัตราของกลุ่ม A ตอนนี้พยายามยืมจากราก ปริมาณการใช้ข้อมูลจำนวนมากเนื่องจาก Segment C ไม่ได้ใช้การรับประกันใด ๆ ) แต่ต้องรอให้ Segment B-> Low Prio ถึงระดับรากด้วย ครั้งหนึ่งที่เกิดขึ้น
กรณีที่ 2:
High Prio-> Segment A และ Low Prio-> Segment B ทั้งสองมีแพ็กเก็ตที่จะส่งอีกครั้ง High Prio-> Segment A จะชนะเพราะมีลำดับความสำคัญสูงกว่า เมื่อถึงอัตราของมันแล้วก็พยายามยืมจาก High Prio ซึ่งมีแบนด์วิธว่าง แต่อยู่ในระดับที่สูงขึ้นก็ต้องรอ Low-Prio-> Segment B อีกครั้งเพื่อให้ได้อัตรา เมื่อทั้งคู่ได้รับอัตราของพวกเขาและทั้งคู่ต้องยืม High Prio-> Segment A จะชนะอีกครั้งจนกว่าจะถึงอัตราของ High Prio class หลังจากนั้นจะพยายามยืมจากรูทซึ่งเหลือแบนด์วิดท์เหลืออีก (แบนด์วิดท์ปกติของ Prio ทั้งหมดไม่ได้ใช้งานในขณะนี้) แต่ต้องรออีกครั้งจนกว่า Low Prio -> Segment B จะถึงขีด จำกัด อัตราของ ชนชั้นพรีโอต่ำและพยายามยืมจากราก ในที่สุดทั้งสองชั้นเรียนพยายามยืมจากรูทโดยคำนึงถึงลำดับความสำคัญก่อนและ High Prio->
ทั้งสองกรณีดูไม่เหมาะสมเนื่องจากบางครั้งการรับส่งข้อมูลแบบเรียลไทม์ต้องรอปริมาณข้อมูลจำนวนมากแม้ว่าจะมีแบนด์วิดท์เหลือเฟือ อย่างไรก็ตามในกรณีที่ 2 ดูเหมือนว่าการรับส่งข้อมูลแบบเรียลไทม์จะต้องรอน้อยกว่าในกรณีที่ 1 เนื่องจากต้องรอจนกว่าอัตราการเข้าชมจำนวนมากจะได้รับผลกระทบซึ่งน่าจะน้อยกว่าอัตราของส่วนทั้งหมด (และในกรณี 1 นั่นคืออัตราที่ต้องรอ) หรือฉันผิดทั้งหมดที่นี่
ฉันคิดถึงการตั้งค่าที่ง่ายขึ้นโดยใช้ qdisc ลำดับความสำคัญ แต่คิวที่มีลำดับความสำคัญมีปัญหาใหญ่ที่พวกเขาก่อให้เกิดความอดอยากหากพวกเขาไม่ จำกัด ความอดอยากไม่เป็นที่ยอมรับ แน่นอนว่าเราสามารถใส่ TBF (Token Bucket Filter) ในแต่ละลำดับความสำคัญเพื่อ จำกัด อัตราและหลีกเลี่ยงความอดอยาก แต่เมื่อทำเช่นนั้นคลาสลำดับความสำคัญเดียวไม่สามารถทำให้อิ่มตัวลิงก์ด้วยตัวเองได้อีกต่อไปแม้ว่าคลาสลำดับความสำคัญอื่น ๆ ทั้งหมด ว่างเปล่า TBF จะป้องกันไม่ให้เกิดขึ้น และนี่ก็เป็นสิ่งที่ดีที่สุดย่อยเพราะเหตุใดคลาสจะไม่ได้รับแบนด์วิธ 100% ของสายถ้าไม่มีคลาสอื่นที่ต้องการในตอนนี้
ความคิดเห็นหรือความคิดเห็นเกี่ยวกับการตั้งค่านี้? ดูเหมือนยากที่จะใช้ tc qdiscs มาตรฐาน ในฐานะโปรแกรมเมอร์มันช่างเป็นเรื่องง่ายถ้าฉันสามารถเขียนกำหนดการของตัวเอง (ซึ่งฉันไม่ได้รับอนุญาตให้ทำ)