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

นี่เป็นแอปพลิเคชั่นบันทึก / นับที่นับจำนวนแพ็กเก็ตและการนับประเภทของแพ็คเก็ต ฯลฯ ในเครือข่ายการแชท p2p ซึ่งเท่ากับประมาณ 4-6 ล้านแพ็กเก็ตในระยะเวลา 5 นาที และเนื่องจากฉันใช้เพียงแค่ "ภาพรวม" ของข้อมูลนี้ฉันจึงลบแพ็กเก็ตที่เก่ากว่า 5 นาทีทุกห้านาที ดังนั้นจำนวนสูงสุดของไอเท็มที่จะอยู่ในคอลเล็กชันนี้คือ 10 ถึง 12 ล้าน

เนื่องจากฉันต้องทำการเชื่อมต่อ 300 กับ superpeers ที่แตกต่างกันจึงเป็นไปได้ที่แต่ละแพ็กเก็ตจะพยายามแทรกอย่างน้อย 300 ครั้ง (ซึ่งอาจเป็นเหตุผลว่าทำไมการเก็บข้อมูลนี้ไว้ในหน่วยความจำจึงเป็นตัวเลือกที่สมเหตุสมผลเท่านั้น)

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

Dictionary<ulong, Packet>

public class Packet
{
    public ushort RequesterPort;
    public bool IsSearch;
    public string SearchText;
    public bool Flagged;
    public byte PacketType;
    public DateTime TimeStamp;
}

ฉันได้ลองใช้ mysql แต่ไม่สามารถติดตามปริมาณข้อมูลที่ฉันต้องการแทรก (ขณะตรวจสอบเพื่อให้แน่ใจว่าไม่ซ้ำกัน) และนั่นคือขณะที่ใช้ธุรกรรม

ฉันพยายาม mongodb แต่การใช้ซีพียูสำหรับมันนั้นบ้าและไม่ได้เก็บไว้อย่างใดอย่างหนึ่ง

ปัญหาหลักของฉันเกิดขึ้นทุก 5 นาทีเพราะฉันลบแพ็กเก็ตทั้งหมดที่เก่ากว่า 5 นาทีและใช้ "ภาพรวม" ของข้อมูลนี้ เช่นฉันใช้การสืบค้น LINQ เพื่อนับจำนวนแพ็คเก็ตที่มีประเภทแพ็คเก็ตบางอย่าง ฉันยังเรียกใช้แบบสอบถาม () ที่แตกต่างกันของข้อมูลที่ฉันดึงข้อมูล 4 ไบต์ (ที่อยู่ IP) ออกจากคีย์ของ keyvaluepair และรวมเข้ากับค่าที่ร้องขอในมูลค่าของ keyvalupair และใช้เพื่อรับจำนวนที่แตกต่างกันของ เพื่อนจากทุกแพ็กเก็ต

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

ตอนนี้จะไม่เป็นปัญหาหากฉันมี ram จำนวนบ้า แต่ vm ที่ฉันใช้งานอยู่นั้น จำกัด อยู่ที่ 2GB ของ ram ในขณะนี้

มีวิธีแก้ปัญหาง่าย ๆ ไหม?

แทนที่จะมีหนึ่งพจนานุกรมและค้นหาพจนานุกรมนั้นสำหรับรายการที่เก่าเกินไป มี 10 พจนานุกรม ทุกๆ 30 วินาทีหรือมากกว่านั้นจะสร้างพจนานุกรม "ปัจจุบัน" ใหม่และทิ้งพจนานุกรมที่เก่าที่สุดโดยไม่ต้องค้นหาเลย

ถัดไปเมื่อคุณยกเลิกพจนานุกรมที่เก่าที่สุดให้วางวัตถุเก่าทั้งหมดลงในคิว FILO ในภายหลังและแทนที่จะใช้ "ใหม่" เพื่อสร้างวัตถุใหม่ดึงวัตถุเก่าออกจากคิว FILO และใช้วิธีการสร้างเก่าขึ้นใหม่ วัตถุ (เว้นแต่ว่าคิวของวัตถุเก่านั้นว่างเปล่า) สิ่งนี้สามารถหลีกเลี่ยงการจัดสรรจำนวนมากและโอเวอร์เฮดการรวบรวมขยะจำนวนมาก

ความคิดแรกที่คิดขึ้นมาคือเหตุผลที่คุณรอ 5 นาที คุณช่วยถ่ายภาพสแนปชอตบ่อยขึ้นและลดภาระงานใหญ่ที่คุณเห็นในขอบเขต 5 นาทีได้หรือไม่?

ประการที่สอง LINQ นั้นยอดเยี่ยมสำหรับรหัสที่รัดกุม แต่ในความเป็นจริงแล้ว LINQ นั้นเป็น syntactic น้ำตาลใน "ปกติ" C # และไม่มีการรับประกันว่ามันจะสร้างรหัสที่ดีที่สุด ในแบบฝึกหัดคุณสามารถลองและเขียนซ้ำจุดที่น่าสนใจด้วย LINQ คุณอาจไม่ปรับปรุงประสิทธิภาพ แต่คุณจะมีความคิดที่ชัดเจนว่าคุณกำลังทำอะไรอยู่และจะทำให้การทำโปรไฟล์ง่ายขึ้น

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

วิธีง่ายๆลองmemcached

• มันได้รับการปรับให้เหมาะกับการทำงานแบบนี้
• มันสามารถใช้หน่วยความจำสำรองในกล่องที่ไม่ว่างไม่เพียง แต่ในกล่องเฉพาะของคุณ
• มันมีกลไกการหมดอายุแคชในตัวซึ่งขี้เกียจไม่มีอาการสะอึก

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

วิธีการที่ซับซ้อนมากขึ้นพยายามRedis

• มันได้รับการปรับให้เหมาะกับการทำงานแบบนี้
• มันมีกลไกการหมดอายุแคชในตัว
• มันชั่ง / เศษได้อย่างง่ายดาย
• มันมีความเพียร

ข้อเสียคือมันซับซ้อนกว่าเล็กน้อย

คุณไม่จำเป็นต้องจัดเก็บแพ็คเกจทั้งหมดสำหรับการสืบค้นที่คุณกล่าวถึง ตัวอย่างเช่น - ตัวนับประเภทแพ็คเกจ:

คุณต้องมีสองอาร์เรย์

int[] packageCounters = new int[NumberOfTotalTypes];
int[,] counterDifferencePerMinute = new int[6, NumberOfTotalTypes];

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

ดังนั้นสำหรับแต่ละแพ็คเกจจะมีการดำเนินการดังต่อไปนี้:

packageCounters[packageType] += 1;
counterDifferencePerMinute[current, packageType] += 1;
if (oneMinutePassed) {
  current = (current + 1) % 6;
  for (int i = 0; i < NumberOfTotalTypes; i++) {
    packageCounters[i] -= counterDifferencePerMinute[current, i];
    counterDifferencePerMinute[current, i] = 0;
}

เมื่อใดก็ตามที่ดัชนีแพคเกจสามารถเรียกดูได้ทันทีและเราจะไม่เก็บแพคเกจทั้งหมด

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

ใช้ struct แทนที่จะเป็นคลาสสำหรับข้อมูลของคุณ (แต่จำไว้ว่ามันถือเป็นค่าที่มีความหมายแบบ pass-by-copy) นี่จะเป็นการค้นหาระดับหนึ่งที่ gc ต้องทำผ่านเครื่องหมาย

ใช้อาร์เรย์ (ถ้าคุณรู้ขนาดของข้อมูลที่คุณกำลังเก็บ) หรือรายการ - ซึ่งใช้อาร์เรย์ภายใน หากคุณต้องการเข้าถึงแบบสุ่มอย่างรวดเร็วให้ใช้พจนานุกรมของดัชนีอาร์เรย์ การทำเช่นนี้จะมีอีกสองระดับ (หรือโหลหรือมากกว่านั้นหากคุณใช้ SortedDictionary) เพื่อให้ gc ต้องค้นหา

การค้นหารายการโครงสร้างอาจเร็วกว่าการค้นหาพจนานุกรม (ขึ้นอยู่กับสิ่งที่คุณทำ) ขึ้นอยู่กับสิ่งที่คุณทำ

การรวมกันของ struct & list จะลดทั้งการใช้หน่วยความจำและขนาดของตัวรวบรวมขยะอย่างมาก