คำถามติดแท็ก performance

ฉันทำงานกับเกมแบบเรียลไทม์ที่จะต้องใช้ฐานข้อมูล (สำหรับคุณสมบัติเช่นโปรไฟล์ผู้เล่นเพื่อนปลดล็อคข่าว ฯลฯ ) เกมนี้เป็นเกมพีซีมาตรฐาน (ไม่ใช่เบราว์เซอร์) และจะใช้ไคลเอนต์เซิร์ฟเวอร์ สถาปัตยกรรม. ฉันยังใหม่กับการใช้ฐานข้อมูลและได้ทำการวิจัยบางอย่างในช่วงไม่กี่วันที่ผ่านมาเมื่อฉันได้พบกับการอภิปรายที่ร้อนแรง: RDBMS vs NoSQL ขณะนี้ฉันกำลังโน้มเอียงไปทาง NoSQL แต่หลังจากอ่านเกี่ยวกับการใช้งานสำหรับแต่ละ (RDBMS และ NoSQL) ฉันก็อยากจะใช้ทั้งสองอย่าง ฉันรู้ว่ามันอาจดูแปลก แต่ขอให้ฉันอธิบายสถานการณ์ของฉัน: ทีมของฉันมีแพ็คเกจเว็บโฮสติ้งที่ใช้ร่วมกันซึ่งมีพื้นที่เก็บข้อมูลและแบนด์วิดธ์ mySQL ไม่ จำกัด ซึ่งเป็นข้อแม้เดียวที่เราสามารถเปิดได้ 25 การเชื่อมต่อในครั้งเดียว (กฎการโฮสต์ที่ใช้ร่วมกัน) ฉันตั้งใจจะใช้สิ่งนี้กับเว็บไซต์ของฉัน (เป็นการใช้งานทั่วไปอย่างไม่ต้องสงสัย) เพื่อโพสต์การอัปเดตข่าวสนับสนุนคุณลักษณะของชุมชน (เช่นความคิดเห็นการอัปโหลดภาพหน้าปกของแฟน ๆ ฯลฯ ) และอื่น ๆ นั่นคือทั้งหมดที่ดีและดี - แต่! นี่คือสิ่งที่น่าสนใจ ... ฉันต้องการแสดงข้อมูลเดียวกันนี้ที่โพสต์บนเว็บไซต์ของฉันในเกม นี่หมายถึงการใช้ mySQL สำหรับทั้งเว็บไซต์และเกมของฉัน นอกจากโพสต์ข่าวและสิ่งที่ชอบฉันวางแผนที่จะใช้มันในเกมสำหรับสิ่งต่าง ๆ เช่นการแชทและรายชื่อเซิร์ฟเวอร์ …

12 multiplayer  performance  client-server  databases 

สิ่งนี้เกี่ยวข้องกับประสิทธิภาพ MMOยกเว้นคำถามนั้นเกี่ยวกับแบนด์วิดท์ นี่เป็นเรื่องของ cpu load ฉันรวบรวม FPS ง่าย ๆ โดยใช้ node.js และ webGL มันง่ายมาก ๆ เหมือนโคลน BuddyMaze ของ MIDI Maze เกิดขึ้นน้อยมากทุกคนเคลื่อนที่ในสองมิติ (ไม่มีความสูง) ยิงขีปนาวุธง่าย ๆ แล้ววิ่งเข้าไปในกำแพง ตอนนี้ถ้าฉันทำการเชื่อมต่อหลายครั้งไปยังเซิร์ฟเวอร์ที่ผู้เล่นทุกคนถ่ายภาพอย่างรวดเร็วในขณะที่หมุนเป็นวงกลมฉันสามารถรับผู้เล่นได้ประมาณ 15 - 20 คนในเกมก่อนที่เซิร์ฟเวอร์จะคายแกนและช้าลง และนี่คือเมื่อทำงานที่ 30 fps บนเซิร์ฟเวอร์ ที่ 10 fps ฉันได้รับการเชื่อมต่อประมาณ 25 - 30 นี่เป็นสิ่งที่ไม่ดีนักเนื่องจากเกมจะมีอะไรอีกมากมายที่ต้องทำในไม่ช้าและฉันจะต้องเพิ่มผู้เล่นให้มากขึ้นเพื่อให้เป็นไปได้ พี่ชายของฉันเพิ่งชี้ให้เห็นสถิติบางอย่างเกี่ยวกับเซิร์ฟเวอร์ TF2 ของเพื่อนร่วมงานของเขา เซิร์ฟเวอร์ของเขามีสเปคต่ำกว่าของเรา แต่มันรัน TF2 ซึ่งเป็นเกมที่ซับซ้อนมากขึ้นอย่างมากที่ 500 …

12 performance  client-server  first-person-shooter 

ทำไมสามัคคีสะท้อนการใช้เพื่อการเข้าถึงMonoBehaviourวิธีการเช่นข้อความAwake, Update, Start, ... ? การใช้ภาพสะท้อนจะไม่ช้าหรือไม่ ทำไมไม่ได้ใช้ประโยชน์จากวิธีการอื่น ๆ เช่นTemplate Method? มันสามารถนิยามเมธอดเป็นนามธรรมในMonoBehaviourคลาสฐานและบังคับให้คลาสย่อยนำไปใช้

12 unity  c#  performance 

เราเริ่มต้นจากขั้นพื้นฐานวิธีการระบบส่วนประกอบที่มีหน่วยงาน ขอสร้างassemblages (ระยะที่ได้มาจากนี้บทความ) เพียงออกของข้อมูลเกี่ยวกับชนิดของชิ้นส่วน มันจะทำแบบไดนามิกที่รันไทม์เช่นเดียวกับที่เราจะเพิ่ม / ลบส่วนประกอบไปยังเอนทิตีทีละคน แต่ขอเพียงแค่ตั้งชื่อได้อย่างแม่นยำมากขึ้นเพราะมันเป็นเพียงเกี่ยวกับข้อมูลประเภท แล้วเราจะสร้างหน่วยงานที่ระบุการชุมนุมทุกครั้งของพวกเขา เมื่อเราสร้างเอนทิตีแล้วชุดประกอบของมันจะไม่เปลี่ยนรูปซึ่งหมายความว่าเราไม่สามารถแก้ไขได้โดยตรง แต่ก็ยังสามารถรับลายเซ็นของเอนทิตีที่มีอยู่ไปยังสำเนาภายในเครื่อง (พร้อมกับเนื้อหา) ทำการเปลี่ยนแปลงที่เหมาะสมและสร้างเอนทิตีใหม่ ของมัน ตอนนี้สำหรับแนวคิดหลัก: เมื่อใดก็ตามที่มีการสร้างเอนทิตีมันจะถูกกำหนดให้กับวัตถุที่เรียกว่าbucket bucketlageซึ่งหมายความว่าเอนทิตีทั้งหมดของลายเซ็นเดียวกันจะอยู่ในคอนเทนเนอร์เดียวกัน (เช่นใน std :: vector) ตอนนี้ระบบเพียงทำซ้ำผ่านทุกกลุ่มที่สนใจและทำงานของพวกเขา วิธีนี้มีข้อดีดังนี้ ส่วนประกอบถูกเก็บไว้ในหน่วยความจำที่ต่อเนื่องกันสองสามชิ้น (แม่นยำ: จำนวนถัง) - ช่วยเพิ่มความเป็นมิตรกับหน่วยความจำและง่ายต่อการทิ้งสถานะเกมทั้งหมด ระบบประมวลผลองค์ประกอบในลักษณะเชิงเส้นซึ่งหมายถึงการปรับปรุงการเชื่อมโยงกันแคช - ลาก่อนพจนานุกรมและหน่วยความจำแบบสุ่มกระโดด การสร้างเอนทิตีใหม่นั้นง่ายเหมือนการทำแผนที่ชุดประกอบเพื่อฝากข้อมูลและผลักดันส่วนประกอบที่ต้องการกลับไปยังเวกเตอร์ การลบเอนทิตีเป็นเรื่องง่ายเหมือนกับการเรียก std :: move เพื่อสลับองค์ประกอบสุดท้ายกับอันที่ถูกลบเพราะลำดับไม่สำคัญในตอนนี้ หากเรามีเอนทิตีจำนวนมากที่มีลายเซ็นที่แตกต่างกันโดยสิ้นเชิงประโยชน์ของการเชื่อมโยงกันของแคชลดน้อยลง แต่ฉันไม่คิดว่ามันจะเกิดขึ้นในแอปพลิเคชันส่วนใหญ่ นอกจากนี้ยังมีปัญหาเกี่ยวกับการทำให้ตัวชี้ใช้ไม่ได้เมื่อมีการจัดสรรเวกเตอร์ใหม่ซึ่งสามารถแก้ไขได้โดยการแนะนำโครงสร้างเช่น: struct assemblage_bucket { struct entity_watcher { assemblage_bucket* owner; entity_id real_index_in_vector; …

12 architecture  performance  entity-system  entity-component 

ฉันต้องการทราบว่าฉันสามารถตรวจสอบเพื่อดูว่าจุดสุดยอดของฉันหรือชิ้นส่วน Shader ของฉันเป็นคอขวดในท่อแสดงผลของฉัน ฉันได้อ่านเกี่ยวกับการใช้glQueryCounterกับGL_TIMESTAMPเป้าหมายเพื่อรับจุดตรวจสอบสัญญาณนาฬิการะหว่างคำสั่ง OpenGL แต่สิ่งเหล่านี้ไม่ได้แยกความแตกต่างระหว่างประเภทของเฉดสี ตัวอย่างเช่นหากหนึ่งเฟรมบน GPU ใช้เวลาในการเรนเดอร์ 8 มิลลิวินาทีฉันสามารถบอกได้หรือไม่ว่าตัวแบ่งยอดใช้เวลา 7 มิลลิวินาทีและแฟรกเมนต์ตัวแบ่งใช้ 1 มิลลิวินาที

11 opengl  shaders  performance  profiling 

ฉันมักจะทำ optimazation ก่อนกำหนดจำนวนมากเมื่อต้องรับมือกับกราฟิก มีหลักการบางอย่างที่ฉันพยายามทำตามอยู่เสมอ: รักษาจำนวนองค์ประกอบ D3D ให้น้อยที่สุด (สถานะการแสดงผลบัฟเฟอร์ตัวติดตั้ง ฯลฯ ) ผูกส่วนประกอบถ้าจำเป็นจริงๆ (ไม่ได้ผูกไว้แล้ว ฯลฯ ) เชี่ยวชาญส่วนประกอบให้มากที่สุด (ตั้งค่า BindFlags ที่จำเป็นเท่านั้นเป็นต้น) สิ่งนี้ทำให้ฉันสร้างสิ่งห่อหุ้มที่ซับซ้อนมากสำหรับการจัดการส่วนประกอบที่สร้างขึ้นและสถานะของการวางท่อในปัจจุบัน สิ่งนี้ไม่เพียงใช้เวลาในการพัฒนาที่มีค่าของฉันเท่านั้น แต่ยังเพิ่มความซับซ้อนอีกชั้นหนึ่ง และที่เลวร้ายที่สุดของทั้งหมด: ฉันไม่รู้ด้วยซ้ำว่ามันคุ้มค่ากับปัญหาหรือไม่ ข้อควรพิจารณาในการปรับให้เหมาะสมของฉันบางอย่างอาจมีการใช้งานในระดับที่ต่ำกว่าและฉันเพิ่งทำซ้ำพวกเขาเพิ่มเวลาที่สูญเสียใน CPU การพิจารณาอื่น ๆ อาจไม่จำเป็นอย่างสมบูรณ์เนื่องจากผลกระทบต่อประสิทธิภาพการทำงานนั้นเล็กน้อย ดังนั้นคำถามของฉันคือ: แนวทางใดข้างต้นที่ใช้ได้และฉันควรทำตามเท่าไหร่? GPU จัดการกับการเปลี่ยนแปลงสถานะอย่างไร จะเกิดอะไรขึ้นถ้าฉันเปลี่ยนสถานะที่ไม่เคยใช้ (ไม่มีการเรียกสายขณะที่ใช้งาน) บทลงโทษที่เกิดขึ้นจริงจากการผูกส่วนประกอบต่าง ๆ มีอะไรบ้าง? ข้อควรพิจารณาด้านประสิทธิภาพอื่น ๆ ที่ควรทำ โปรดอย่าเพิ่งบอกฉันว่าฉันไม่ควรสนใจเรื่องการแสดงจนกว่าจะถึงขีด จำกัด ที่แท้จริง ในขณะที่เห็นได้ชัดว่าเป็นเรื่องจริงจากมุมมองของภาคปฏิบัติฉันให้ความสนใจในทฤษฎีเป็นหลัก ฉันต้องการต่อสู้กับการสร้างกรอบกราฟิกที่ดีที่สุดและฉันไม่คิดว่าฉันจะทำเช่นนั้นได้ด้วยการบรรยายเรื่อง การจัดการส่วนประกอบ ขณะนี้ฉันกำลังเขียนแอพพลิเคชั่น DirectX 11 ใน …

11 directx  performance 

ฉันอ่านเกี่ยวกับการสร้างการแสดงผลแฟลชดั้งเดิมBitmapDataกับการสร้างเฟรมบัฟเฟอร์แบบกำหนดเองและคำตอบบางข้อนั้นขัดแย้งกันเล็กน้อยดังนั้นฉันจึงสงสัยว่า: โดยทั่วไปแล้ววิธีที่ดีที่สุดที่จะใช้เส้นทางบัฟเฟอร์บิตแมปที่กำหนดเองหรือเป็นการดีที่สุดที่จะปล่อยให้การแสดงผลไปยังเอ็นจิ้นแฟลช หากคุณใช้ภาพเคลื่อนไหวเวกเตอร์MovieClipซึ่งต่างจากสไปรต์นั่นจะเปลี่ยนคำตอบข้างต้นหรือไม่? ถ้าเป็นเช่นนั้นเป็นวิธีปฏิบัติที่ดีที่สุดในการใช้ภาพเคลื่อนไหวแบบผี (ฉันกำหนดเป้าหมายเป็น Flash 10 หากสร้างความแตกต่าง)

11 flash  optimization  sprites  performance 

วิธีที่มีประสิทธิภาพและรวดเร็วที่สุดในการแปลง Vector3 เป็น Vector2 คืออะไร การคัดเลือกนักแสดง: Vector2 vector2 = (Vector2)vector3; การเริ่มต้น Vector2 ใหม่: Vector2 vector2 = new Vector2(vector3.x, vector3.y); หรือมีวิธีอื่นที่ฉันไม่รู้

11 unity  c#  performance 

ตัวอย่างเช่นใน Mac Mini ของฉันกับ Bootcamp Team Fortress 2 ทำงานที่ประมาณ 20fps ใน OSX และ 80fps ใน Windows นี่เป็นกรณีทั่วไป ทำไมนี้

11 performance  windows  macos 

เมื่อเร็ว ๆ นี้ฉันติดปัญหาที่คิดเกี่ยวกับวิธีที่ดีที่สุดในการสร้างภูมิประเทศในเกมของฉัน ในโครงการอื่นฉันมักใช้ความสูงของแผนที่ดังนั้นงานหลักทั้งหมดจึงขึ้นอยู่กับเครื่องยนต์ที่ใช้ แต่ตอนนี้ไม่สามารถทำได้เพราะภูมิประเทศมีรูปหลายเหลี่ยมหลายล้านที่ต้องวาดอย่างแม่นยำ นอกจากนี้หลายคนไม่สามารถแยกวิเคราะห์จากเวกเตอร์ Y (เนื่องจากรูปหลายเหลี่ยมที่ซ่อนอยู่ด้านล่าง) นั่นคือแผนผังความสูงไม่เป็นประโยชน์ที่นี่ ในกรณีนี้ฉันต้องใช้วัตถุ COLLADA บางคนบอกให้ฉันแบ่งโมเดลด้วยตัวเองภายในซอฟต์แวร์อย่าง Blender แต่น่าเสียดายที่มันไม่สามารถทำได้เพราะภูมิประเทศเหล่านี้ถูกสร้างขึ้นเป็นชิ้น ๆ ในซอฟต์แวร์อื่นและโหลดหลังจากเข้าสู่เกม ดังนั้นนี่จะเป็นงานที่ยิ่งใหญ่ที่จะต้องหั่นมันด้วยตนเองทุกครั้ง ดังนั้นตั้งแต่สัปดาห์ที่ฉันได้ศึกษาเกี่ยวกับวิธีที่ฉันสามารถแก้ปัญหานี้และขั้นตอนการโหลดตาข่ายนี้ภูมิประเทศภูมิประเทศตาม frustrum กล้องบันทึกประสิทธิภาพมากที่สุดเท่าที่เป็นไปได้ ฉันพบเอกสารจำนวนมากเกี่ยวกับการสร้างตาข่ายโพรซีเดอร์และฉันคิดว่าปัญหาของฉันสามารถแก้ไขได้โดยการแมปตาข่ายเข้ากับแปด นี่คืองานที่ยิ่งใหญ่อย่างน้อยสำหรับฉันและนั่นคือเหตุผลที่ฉันมาที่นี่เพราะฉันไม่ต้องการเสี่ยงที่จะไปในเส้นทางที่ผิดโดยไม่ได้ยินจากคนที่มีประสบการณ์ กล่าวโดยย่อฉันมีจุดยอดและดัชนีนับล้านที่รวมกันเป็นภูมิประเทศ แต่ด้วยเหตุผลที่ชัดเจนว่าฉันไม่สามารถวาดมันได้ในเวลาเดียวกัน จำเป็นต้องมีขั้นตอนบางอย่าง วิธีที่ดีที่สุดในการทำเช่นนั้นคือการรักษาตาข่ายขนาดใหญ่เป็นภูมิประเทศ? มีหนังสือเฉพาะเกี่ยวกับเรื่องนั้นไหม? มีวิธีที่ดีที่สุดที่จะใช้หรือไม่ ขออภัยสำหรับข้อผิดพลาดใด ๆ ฉันเป็นสามเณรมากในพื้นที่นี้

10 opengl  3d  performance  terrain  octree 

ฉันจะใช้แสงที่รวดเร็วพร้อมแสงหลายดวงได้อย่างไร ฉันไม่ต้องการ จำกัด ผู้เล่นเขาสามารถวางจำนวนไม่ จำกัด และอาจมีการซ้อนทับกัน (จุด) ไฟในระดับ ปัญหาคือเฉดสีที่มีลูปแบบไดนามิกซึ่งจะจำเป็นในการคำนวณแสงมักจะช้ามาก ฉันมีความคิดว่าถ้ามันเป็นไปได้ในเวลาคอมไพล์ไทม์เพื่อรวบรวม shader n คูณโดยที่ n คือจำนวนแสง หากทราบหมายเลข n ในเวลาคอมไพล์ไทม์สามารถยกเลิกการวนซ้ำได้โดยอัตโนมัติ เป็นไปได้ไหมที่จะสร้าง shader เดียวกันรุ่น n ที่มีจำนวนแสงแตกต่างกัน? ที่รันไทม์ฉันสามารถตัดสินใจได้ว่า shader ใดที่จะใช้ในส่วนของระดับ

10 xna  shaders  performance  hlsl  lighting 

ด้วยความพร้อมของการคำนวณเฉดสีสำหรับ DirectX และ OpenGL ตอนนี้เป็นไปได้ที่จะใช้อัลกอริธึมมากมายโดยไม่ต้องผ่านขั้นตอนการแรสเตอร์และแทนที่จะใช้การคำนวณเอนกประสงค์บน GPU เพื่อแก้ปัญหา สำหรับอัลกอริธึมบางสิ่งนี้ดูเหมือนจะเป็นวิธีแก้ปัญหาแบบ canonical ที่ใช้งานง่ายเพราะพวกมันไม่ใช่ rasterization based และ shaders ที่ใช้ rasterization ดูเหมือนจะเป็นวิธีแก้ปัญหาในการควบคุมพลังงาน GPU (ตัวอย่างง่าย ๆ : การสร้างพื้นผิวของเสียง ) มีอัลกอริทึมที่สามารถใช้งานได้ทั้งสองวิธีมีประโยชน์ด้านประสิทธิภาพการทำงานทั่วไป (ที่มีศักยภาพ) มากกว่าการใช้ตัวประมวลผลร่วมกับเส้นทางปกติหรือไม่ มีข้อเสียที่เราควรระวัง (ตัวอย่างเช่นมีค่าใช้จ่ายที่ผิดปกติบางอย่างเพื่อเปลี่ยนจาก / เป็นคำนวณเฉดสีที่รันไทม์)? อาจมีประโยชน์หรือข้อเสียอื่น ๆ ที่ควรพิจารณาเมื่อเลือกระหว่างสองรายการนี้หรือไม่?

10 performance  gpgpu 

ฉันพยายามที่จะทำฮาร์ดแวร์ instancing แต่ฉันตีปัญหาประสิทธิภาพการทำงานที่แปลก อัตราเฟรมเฉลี่ยอยู่ที่ประมาณ 45 แต่มันขาด ๆ หาย ๆ อย่างมาก หน้าต่าง SynchronizeWithVerticalRetrace = false IsFixedTimeStep = false PresentationInterval = PresentInterval.Immediate ภาพด้านล่างแสดงเวลาที่ฉันวัดได้ (พร้อมStopwatch) กราฟระดับบนสุดคือเวลาที่ใช้ในDrawวิธีการและกราฟด้านล่างเป็นเวลาตั้งแต่สิ้นสุดDrawจนจบUpdate เดือยแหลมนั้นอยู่ห่างกันเกือบ 1 วินาทีและมักจะ 2,3,4 หรือ 5 เท่าของเวลาปกติ เฟรมทันทีหลังจากขัดขวางไม่ใช้เวลาเลย ฉันตรวจสอบแล้วว่าไม่ใช่ตัวรวบรวมขยะ ขณะนี้ฉันกำลังวางตาข่ายที่ประกอบด้วยสามเหลี่ยม 12 รูปและจุดยอด 36 จุดเป็นรายการรูปสามเหลี่ยม (ฉันรู้ว่ามันไม่เหมาะ แต่เป็นเพียงการทดสอบ) โดยมี 1 ล้านอินสแตนซ์ ถ้าฉันแบทช์อินสแตนซ์การดึงการโทรออกเป็นส่วนเล็ก ๆ ของ 250 อินสแตนซ์แต่ละปัญหาจะบรรเทา แต่การใช้ cpu เพิ่มขึ้นอย่างมีนัยสำคัญ …

10 xna  performance 

คำถามนี้ค่อนข้างยุ่งยาก แต่ฉันจะพยายามทำให้ชัดเจน ช่วยบอกว่าฉันกำลังสร้างเกมออนไลน์ (ไม่ใช่ MMO-scale) แต่นั่นก็รองรับผู้เล่นให้มากที่สุดเท่าที่จะทำได้ในแนวทางเซิร์ฟเวอร์ที่เชื่อถือได้ ผมต้องการที่ยิ่งใหญ่ของโลกที่มีจำนวนมากของศัตรู AI จำลอง ฉันรับทราบถึงกลยุทธ์สองสามประการในการประหยัด CPU ของเซิร์ฟเวอร์โดยแบ่งย่อยพื้นที่และไม่ประมวลผลสิ่งที่ไม่ต้องการการประมวลผล ฉันแบ่งโลกแล้วตามภูมิภาคซึ่งจะต้องใช้เวลาโหลดและการเปลี่ยนภาพเล็กน้อยซึ่งฉันคิดว่าเป็นสิ่งสำคัญในการรักษาคุณภาพของการเล่นเกมเมื่อเล่นในพื้นที่ ฉันไม่ได้คาดหวังว่าผู้เล่นจะอยู่ในมากกว่าหนึ่งหรือสองภูมิภาค ปัญหาคือภูมิภาคสามารถมีขนาดใหญ่และมี NPC จำนวนมากในเวลาเดียวกัน ฉันจะจัดการสิ่งนี้โดยไม่กระทบต่อประสบการณ์ของผู้เล่นได้อย่างไร วิธีการเช่นเซิร์ฟเวอร์เดียวต่อภูมิภาคและเหมือนกันไม่ได้อยู่ในตาราง ฉันส่วนใหญ่กำลังมองหาโครงสร้างข้อมูลเพื่อเก็บพยุหะศัตรูและแม้แต่ NPC ที่สงบสุข ในการสรุปคำถามโปรดทราบว่ามียานพาหนะอยู่ดังนั้นจึงรวดเร็วในการเดินทางภายในภูมิภาคซึ่งมีอิทธิพลต่อ "เมื่อ" ถึงการเลือกพื้นที่

10 multiplayer  performance  data  architecture  space-partitioning 

ฉันจะใช้พูลวัตถุสำหรับระบบอนุภาคของฉันใน Java จากนั้นฉันพบสิ่งนี้ใน Wikipedia ในการใช้ถ้อยคำใหม่กล่าวว่ากลุ่มวัตถุไม่คุ้มค่าที่จะใช้ในภาษาที่ได้รับการจัดการเช่น Java และ C # เนื่องจากการจัดสรรใช้เวลาเพียงสิบการดำเนินการเมื่อเทียบกับหลายร้อยในภาษาที่ไม่มีการจัดการเช่น C ++ แต่อย่างที่เรารู้กันดีว่าทุกคำสั่งอาจทำให้ประสิทธิภาพของเกมแย่ลง ตัวอย่างเช่นพูลของไคลเอ็นต์ใน MMO: ไคลเอ็นต์จะไม่เข้าและออกจากพูลเร็วเกินไป แต่อนุภาคอาจได้รับการต่ออายุหลายสิบครั้งในหนึ่งวินาที คำถามคือ: มันคุ้มค่าหรือไม่ที่จะใช้กลุ่มวัตถุสำหรับอนุภาค (โดยเฉพาะกลุ่มที่ตายและสร้างใหม่อย่างรวดเร็ว) ในภาษาที่มีการจัดการหรือไม่?

10 performance  design-patterns  particles