ฉันควรใช้คอนเทนเนอร์ STL ใดสำหรับ FIFO

คอนเทนเนอร์ STL ใดที่เหมาะกับความต้องการของฉันมากที่สุด โดยพื้นฐานแล้วฉันมีคอนเทนเนอร์กว้าง 10 องค์ประกอบซึ่งฉันมีpush_backองค์ประกอบใหม่อย่างต่อเนื่องในขณะที่ใช้องค์ประกอบที่pop_frontเก่าแก่ที่สุด (ประมาณหนึ่งล้านครั้ง)

ฉันกำลังใช้ a std::dequeสำหรับงานนี้ แต่สงสัยว่า a std::listจะมีประสิทธิภาพมากกว่านี้หรือไม่เพราะฉันไม่จำเป็นต้องจัดสรรตัวเองใหม่ (หรือบางทีฉันอาจเข้าใจผิดว่าเป็นstd::dequea std::vector?) หรือมีคอนเทนเนอร์ที่มีประสิทธิภาพมากกว่าสำหรับความต้องการของฉันหรือไม่?

ปล. ฉันไม่ต้องการการเข้าถึงแบบสุ่ม

เนื่องจากมีคำตอบมากมายคุณจึงอาจสับสน แต่สรุป:

ใช้ไฟล์std::queue. เหตุผลง่ายๆก็คือโครงสร้าง FIFO คุณต้องการ FIFO คุณใช้ไฟล์std::queue.

มันทำให้เจตนาของคุณชัดเจนสำหรับคนอื่นและแม้แต่ตัวคุณเอง A std::listหรือstd::dequeไม่ รายการสามารถแทรกและลบได้ทุกที่ซึ่งไม่ใช่สิ่งที่โครงสร้าง FIFO ควรทำและdequeสามารถเพิ่มและลบจากปลายด้านใดด้านหนึ่งซึ่งเป็นสิ่งที่โครงสร้าง FIFO ไม่สามารถทำได้

นี่คือเหตุผลที่คุณควรใช้ไฟล์queue.

ตอนนี้คุณถามเกี่ยวกับประสิทธิภาพ ประการแรกจำกฎง่ายๆนี้ไว้เสมอ: รหัสที่ดีก่อนประสิทธิภาพสุดท้าย

เหตุผลง่ายๆก็คือคนที่มุ่งมั่นเพื่อประสิทธิภาพก่อนที่ความสะอาดและความสง่างามมักจะเสร็จสิ้นเป็นอันดับสุดท้าย รหัสของพวกเขากลายเป็นเรื่องเหลวไหลเพราะพวกเขาละทิ้งทุกสิ่งที่ดีเพื่อที่จะไม่ได้อะไรจากมัน

การเขียนโค้ดที่ดีและอ่านได้ก่อนอื่นปัญหาด้านประสิทธิภาพส่วนใหญ่ของคุณจะคลี่คลายเอง และหากในภายหลังคุณพบว่าประสิทธิภาพของคุณขาดหายไปตอนนี้คุณสามารถเพิ่ม profiler ลงในโค้ดที่ดีและสะอาดของคุณได้อย่างง่ายดายและค้นหาว่าปัญหาอยู่ที่ใด

ที่กล่าวมาทั้งหมดstd::queueเป็นเพียงอะแดปเตอร์เท่านั้น มีอินเทอร์เฟซที่ปลอดภัย แต่ใช้คอนเทนเนอร์อื่นที่อยู่ด้านใน คุณสามารถเลือกคอนเทนเนอร์พื้นฐานนี้และช่วยให้มีความยืดหยุ่นได้ดี

คุณควรใช้คอนเทนเนอร์ใด เรารู้ว่าstd::listและstd::dequeทั้งสองให้ฟังก์ชั่นที่จำเป็น ( push_back(), pop_front()และfront()) ดังนั้นวิธีที่เราจะตัดสินใจ?

ก่อนอื่นให้ทำความเข้าใจว่าการจัดสรรหน่วยความจำ (และการจัดสรร) ไม่ใช่สิ่งที่ต้องทำโดยทั่วไปเนื่องจากเกี่ยวข้องกับการออกไปที่ระบบปฏิบัติการและขอให้ทำอะไรบางอย่าง A listต้องจัดสรรหน่วยความจำทุกครั้งที่มีการเพิ่มบางสิ่งและยกเลิกการจัดสรรหน่วยความจำเมื่อมันหายไป

A dequeในทางกลับกันจัดสรรเป็นชิ้น ๆ จะจัดสรรน้อยกว่า a list. คิดว่ามันเป็นรายการ แต่แต่ละหน่วยความจำสามารถเก็บได้หลายโหนด (แน่นอนฉันขอแนะนำให้คุณเรียนรู้วิธีการทำงานจริงๆ)

ดังนั้นด้วยสิ่งนั้นเพียงอย่างเดียวdequeควรทำงานได้ดีกว่าเพราะมันไม่ได้จัดการกับหน่วยความจำบ่อยเท่า เมื่อผสมกับความจริงที่ว่าคุณกำลังจัดการข้อมูลที่มีขนาดคงที่อาจไม่จำเป็นต้องจัดสรรหลังจากการส่งผ่านข้อมูลครั้งแรกในขณะที่รายการจะถูกจัดสรรและจัดสรรอย่างต่อเนื่อง

สิ่งที่สองที่จะเข้าใจได้ประสิทธิภาพแคช การออกไปที่ RAM นั้นช้าดังนั้นเมื่อจำเป็นต้องใช้ CPU จริงๆมันจะทำให้ดีที่สุดในช่วงเวลานี้โดยการดึงหน่วยความจำกลับไปในแคช เนื่องจากมีการdequeจัดสรรในหน่วยความจำจึงมีแนวโน้มว่าการเข้าถึงองค์ประกอบในคอนเทนเนอร์นี้จะทำให้ CPU นำส่วนที่เหลือของคอนเทนเนอร์กลับมาด้วย ตอนนี้การเข้าถึงเพิ่มเติมdequeจะเป็นไปอย่างรวดเร็วเนื่องจากข้อมูลอยู่ในแคช

ซึ่งแตกต่างจากรายการที่ข้อมูลจะถูกจัดสรรทีละรายการ ซึ่งหมายความว่าข้อมูลอาจกระจายออกไปทั่วทุกที่ในหน่วยความจำและประสิทธิภาพของแคชจะไม่ดี

ดังนั้นเมื่อพิจารณาแล้วdequeควรเป็นทางเลือกที่ดีกว่า ด้วยเหตุนี้จึงเป็นคอนเทนเนอร์เริ่มต้นเมื่อใช้ไฟล์queue. ที่กล่าวมาทั้งหมดนี้ยังคงเป็นเพียงการคาดเดาที่มีการศึกษา (มาก): คุณจะต้องกำหนดโปรไฟล์รหัสนี้โดยใช้การdequeทดสอบในครั้งเดียวและlistอีกรายการหนึ่งเพื่อให้ทราบอย่างแน่นอน

แต่อย่าลืมว่า: รับโค้ดที่ทำงานร่วมกับอินเทอร์เฟซที่สะอาดหมดจดแล้วกังวลเรื่องประสิทธิภาพ

จอห์นทำให้เกิดความกังวลว่าการห่อlistหรือdequeจะทำให้ประสิทธิภาพลดลง อีกครั้งเขาหรือฉันไม่สามารถพูดได้อย่างแน่นอนโดยไม่ต้องทำโปรไฟล์ด้วยตัวเอง แต่มีโอกาสที่คอมไพเลอร์จะอินไลน์การเรียกที่queueทำให้ นั่นคือเมื่อคุณพูดqueue.push()มันจะพูดจริงๆqueue.container.push_back()โดยข้ามการเรียกฟังก์ชันไปโดยสิ้นเชิง

อีกครั้งนี่เป็นเพียงการคาดเดาที่มีการศึกษา แต่การใช้queueจะไม่ลดประสิทธิภาพเมื่อเทียบกับการใช้คอนเทนเนอร์ที่อยู่เบื้องหลัง อย่างที่ฉันเคยพูดไปแล้วให้ใช้queueเพราะมันสะอาดใช้งานง่ายและปลอดภัยและถ้ามันกลายเป็นโปรไฟล์และการทดสอบที่มีปัญหาจริงๆ

std::queueตรวจสอบ มัน wraps std::dequeประเภทภาชนะพื้นฐานและภาชนะเริ่มต้นคือ

ในกรณีที่ผลการดำเนินงานที่สำคัญจริงๆตรวจสอบBoost ห้องสมุดกันชนกลม

ฉันpush_backสร้างองค์ประกอบใหม่อย่างต่อเนื่องในขณะที่ใช้องค์ประกอบที่pop_frontเก่าแก่ที่สุด (ประมาณล้านครั้ง)

ล้านไม่ใช่ตัวเลขใหญ่ในการคำนวณ ตามที่คนอื่นแนะนำให้ใช้ a std::queueเป็นวิธีแก้ปัญหาแรกของคุณ ในกรณีที่ไม่น่าจะเกิดขึ้นช้าเกินไปให้ระบุคอขวดโดยใช้ profiler (อย่าเดา!) และนำไปใช้ใหม่โดยใช้คอนเทนเนอร์อื่นที่มีอินเทอร์เฟซเดียวกัน

ทำไมไม่std::queue? ทั้งหมดก็มีเป็นและpush_backpop_front

คิวน่าจะเป็นอินเตอร์เฟซที่เรียบง่ายกว่าdequeแต่สำหรับรายชื่อดังกล่าวมีขนาดเล็กแตกต่างกันในการทำงานอาจจะเป็นเล็กน้อย

กันไปสำหรับรายการ มันเป็นเพียงตัวเลือกของ API ที่คุณต้องการ

ใช้ a std::queueแต่ระวังการแลกเปลี่ยนประสิทธิภาพของสองContainerคลาสมาตรฐาน

ตามค่าเริ่มต้นstd::queueคืออะแดปเตอร์ที่อยู่ด้านบนของstd::deque. โดยทั่วไปแล้วจะให้ประสิทธิภาพที่ดีเมื่อคุณมีคิวจำนวนน้อยที่มีรายการจำนวนมากซึ่งเป็นเนื้อหาทั่วไป

แต่ไม่ได้เป็นคนตาบอดที่จะดำเนินการตามมาตรฐาน :: deque โดยเฉพาะ:

"... โดยทั่วไป deques จะมีต้นทุนหน่วยความจำน้อยที่สุด deque ที่ถือองค์ประกอบเพียงตัวเดียวจะต้องจัดสรรอาร์เรย์ภายในเต็มรูปแบบ (เช่นขนาดวัตถุ 8 เท่าบน libstdc ++ 64 บิต; 16 เท่าของขนาดวัตถุหรือ 4096 ไบต์แล้วแต่จำนวนใดจะใหญ่กว่า บน libc ++ 64 บิต) "

หากต้องการสรุปให้สันนิษฐานว่ารายการคิวเป็นสิ่งที่คุณต้องการจัดคิวกล่าวคือมีขนาดเล็กพอสมควรหากคุณมี 4 คิวแต่ละคิวมี 30,000 รายการการstd::dequeติดตั้งจะเป็นตัวเลือกที่คุณเลือก ในทางกลับกันหากคุณมี 30,000 คิวแต่ละรายการมี 4 รายการแสดงว่าการstd::listติดตั้งใช้งานจะเหมาะสมกว่าปกติเนื่องจากคุณจะไม่ตัดstd::dequeค่าใช้จ่ายในสถานการณ์นั้น

คุณจะได้อ่านความคิดเห็นมากมายเกี่ยวกับวิธีที่แคชเป็นราชาวิธีที่ Stroustrup เกลียดรายการที่เชื่อมโยง ฯลฯ และทั้งหมดนี้เป็นจริงภายใต้เงื่อนไขบางประการ อย่ายอมรับมันด้วยความเชื่อที่มืดบอดเพราะในสถานการณ์ที่สองของเรามีไม่น่าเป็นไปได้ที่การstd::dequeใช้งานเริ่มต้นจะดำเนินการ ประเมินการใช้งานและวัดผล

กรณีนี้ง่ายพอที่คุณจะเขียนของคุณเองได้ นี่คือสิ่งที่ใช้ได้ดีสำหรับสถานการณ์ไมโครคอนโทรเลอร์ที่การใช้ STL ใช้พื้นที่มากเกินไป เป็นวิธีที่ดีในการส่งข้อมูลและสัญญาณจากตัวจัดการขัดจังหวะไปยังลูปหลักของคุณ

// FIFO with circular buffer
#define fifo_size 4

class Fifo {
  uint8_t buff[fifo_size];
  int writePtr = 0;
  int readPtr = 0;
  
public:  
  void put(uint8_t val) {
    buff[writePtr%fifo_size] = val;
    writePtr++;
  }
  uint8_t get() {
    uint8_t val = NULL;
    if(readPtr < writePtr) {
      val = buff[readPtr%fifo_size];
      readPtr++;
      
      // reset pointers to avoid overflow
      if(readPtr > fifo_size) {
        writePtr = writePtr%fifo_size;
        readPtr = readPtr%fifo_size;
      }
    }
    return val;
  }
  int count() { return (writePtr - readPtr);}
};