Kontainer STL mana yang harus saya gunakan untuk FIFO?

Wadah STL mana yang paling sesuai dengan kebutuhan saya? Saya pada dasarnya memiliki wadah lebar 10 elemen di mana saya terus push_backelemen baru sementara pop_frontelemen tertua (sekitar satu juta kali).

Saat ini saya menggunakan std::dequeuntuk tugas tersebut tetapi bertanya-tanya apakah a std::listakan lebih efisien karena saya tidak perlu mengalokasikan ulang sendiri (atau mungkin saya salah mengira std::dequea std::vector?). Atau adakah wadah yang lebih efisien untuk kebutuhan saya?

PS Saya tidak perlu akses acak

Karena ada banyak sekali jawaban, Anda mungkin bingung, tetapi untuk diringkas:

Gunakan a std::queue. Alasannya sederhana: ini adalah struktur FIFO. Anda menginginkan FIFO, Anda menggunakan file std::queue.

Itu membuat niat Anda jelas bagi orang lain, dan bahkan diri Anda sendiri. A std::listatau std::dequetidak. Sebuah daftar dapat disisipkan dan dihapus di mana saja, yang tidak seharusnya dilakukan oleh struktur FIFO, dan dequedapat menambah dan menghapus dari kedua ujungnya, yang juga merupakan sesuatu yang tidak dapat dilakukan oleh struktur FIFO.

Inilah mengapa Anda harus menggunakan file queue.

Sekarang, Anda bertanya tentang kinerja. Pertama, selalu ingat aturan praktis yang penting ini: Kode bagus dulu, performa terakhir.

Alasannya sederhana: orang yang mengupayakan penampilan sebelum kebersihan dan keanggunan hampir selalu menjadi yang terakhir. Kode mereka menjadi omong kosong, karena mereka telah meninggalkan semua yang baik untuk benar-benar mendapatkan apa-apa darinya.

Dengan menulis kode yang bagus dan dapat dibaca terlebih dahulu, sebagian besar masalah kinerja Anda akan teratasi sendiri. Dan jika nanti Anda menemukan kinerja Anda kurang, sekarang mudah untuk menambahkan profiler ke kode Anda yang bagus dan bersih, dan mencari tahu di mana masalahnya.

Itu semua dikatakan, std::queuehanya adaptor. Ini menyediakan antarmuka yang aman, tetapi menggunakan wadah yang berbeda di dalam. Anda dapat memilih wadah dasar ini, dan ini memungkinkan banyak fleksibilitas.

Jadi, wadah dasar mana yang harus Anda gunakan? Kita tahu bahwa std::listdan std::dequekeduanya memberikan fungsi yang diperlukan ( push_back(), pop_front(), dan front()), jadi bagaimana kita memutuskan?

Pertama, pahami bahwa mengalokasikan (dan membatalkan alokasi) memori bukanlah hal yang cepat untuk dilakukan, umumnya, karena melibatkan keluar ke OS dan memintanya untuk melakukan sesuatu. A listharus mengalokasikan memori setiap kali ada sesuatu yang ditambahkan, dan mengalokasikannya ketika hilang.

A deque, di sisi lain, mengalokasikan dalam potongan. Ini akan mengalokasikan lebih jarang dari a list. Anggap saja sebagai daftar, tetapi setiap bagian memori dapat menampung banyak node. (Tentu saja, saya menyarankan agar Anda benar-benar mempelajari cara kerjanya .)

Jadi, dengan itu saja a dequeharus berkinerja lebih baik, karena tidak sering berurusan dengan memori. Dicampur dengan fakta Anda menangani data dengan ukuran konstan, mungkin tidak perlu mengalokasikan setelah melewati pertama melalui data, sedangkan daftar akan terus mengalokasikan dan membatalkan alokasi.

Hal kedua yang perlu dipahami adalah kinerja cache . Keluar ke RAM itu lambat, jadi ketika CPU benar-benar membutuhkannya, itu memanfaatkan yang terbaik dari waktu ini dengan mengambil sebagian memori bersamanya, ke dalam cache. Karena a dequemengalokasikan dalam potongan memori, kemungkinan mengakses elemen dalam penampung ini akan menyebabkan CPU mengembalikan sisa penampungnya juga. Sekarang akses lebih lanjut ke dequeakan lebih cepat, karena datanya ada dalam cache.

Ini tidak seperti daftar, di mana data dialokasikan satu per satu. Ini berarti bahwa data dapat tersebar di semua tempat di memori, dan kinerja cache akan menjadi buruk.

Jadi, mengingat itu, dequeseharusnya menjadi pilihan yang lebih baik. Inilah mengapa ini adalah penampung default saat menggunakan file queue. Meskipun demikian, ini masih hanya tebakan (sangat) terpelajar: Anda harus membuat profil kode ini, menggunakan dequetes dalam satu dan tes listlain untuk benar-benar mengetahui dengan pasti.

Tapi ingat: dapatkan kode yang berfungsi dengan antarmuka yang bersih, lalu khawatirkan performa.

John menimbulkan kekhawatiran bahwa membungkus listatau dequeakan menyebabkan penurunan kinerja. Sekali lagi, dia dan saya tidak dapat mengatakan dengan pasti tanpa membuat profilnya sendiri, tetapi kemungkinan besar kompilator akan menyebariskan panggilan yang queuedibuat. Artinya, ketika Anda mengatakan queue.push(), itu benar-benar hanya akan mengatakan queue.container.push_back(), melewatkan panggilan fungsi sepenuhnya.

Sekali lagi, ini hanya tebakan, tetapi menggunakan queuetidak akan menurunkan kinerja, jika dibandingkan dengan menggunakan wadah mentah yang mendasarinya. Seperti yang saya katakan sebelumnya, gunakan queue, karena bersih, mudah digunakan, dan aman, dan jika benar-benar menjadi profil masalah dan uji.

Lihat std::queue. Ini membungkus jenis penampung yang mendasari, dan penampung default adalah std::deque.

Jika kinerja sangat penting, lihat pustaka buffer melingkar Boost .

Saya terus menerus push_backelemen baru sambil pop_fronting elemen tertua (sekitar satu juta kali).

Sejuta bukanlah angka yang besar dalam komputasi. Seperti yang disarankan orang lain, gunakan a std::queuesebagai solusi pertama Anda. Jika terjadi terlalu lambat, identifikasi hambatan menggunakan profiler (jangan tebak!) Dan implementasikan ulang menggunakan penampung berbeda dengan antarmuka yang sama.

Mengapa tidak std::queue? Semua yang dimilikinya adalah push_backdan pop_front.

Sebuah antrian mungkin antarmuka sederhana daripada deque tapi untuk seperti daftar kecil, perbedaan kinerja mungkin diabaikan.

Sama halnya dengan daftar . Ini tergantung pada pilihan API yang Anda inginkan.

Gunakan a std::queue, tetapi perhatikan pengorbanan kinerja dari dua Containerkelas standar .

Secara default, std::queueadalah adaptor di atas std::deque. Biasanya, itu akan memberikan kinerja yang baik di mana Anda memiliki sejumlah kecil antrian yang berisi banyak entri, yang bisa dibilang kasus umum.

Namun, jangan buta terhadap implementasi std :: deque . Secara khusus:

"... deques biasanya memiliki biaya memori minimal yang besar; deque yang hanya menampung satu elemen harus mengalokasikan array internal penuhnya (misalnya 8 kali ukuran objek pada 64-bit libstdc ++; 16 kali ukuran objek atau 4096 byte, mana saja yang lebih besar , di 64-bit libc ++). "

Untuk menjernihkannya, anggaplah bahwa entri antrian adalah sesuatu yang Anda ingin antri, misalnya ukurannya cukup kecil, maka jika Anda memiliki 4 antrian, masing-masing berisi 30.000 entri, std::dequeimplementasi akan menjadi opsi pilihan. Sebaliknya, jika Anda memiliki 30.000 antrian, masing-masing berisi 4 entri, maka kemungkinan besar std::listpenerapannya akan optimal, karena Anda tidak akan pernah mengamortisasi std::dequebiaya overhead dalam skenario itu.

Anda akan membaca banyak opini tentang bagaimana cache adalah raja, bagaimana Stroustrup membenci daftar tertaut, dll., Dan semua itu benar, dalam kondisi tertentu. Hanya saja, jangan menerimanya dengan keyakinan buta, karena dalam skenario kedua kami di sana, sangat tidak mungkin std::dequeimplementasi default akan berfungsi. Evaluasi penggunaan dan ukuran Anda.

Kasus ini cukup sederhana sehingga Anda bisa menuliskannya sendiri. Ini adalah sesuatu yang bekerja dengan baik untuk situasi mikrokontroler di mana penggunaan STL memakan terlalu banyak ruang. Ini adalah cara yang bagus untuk melewatkan data dan sinyal dari penangan interupsi ke loop utama Anda.

// 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);}
};