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

IntelliJ IDEA แนะนำให้ฉันตอนนี้เพื่อแทนที่ลูปสำหรับแต่ละลูปต่อไปนี้ด้วยการเรียก Java 8 "forEach": for (Object o : objects) { if (o instanceof SomeObject) { doSomething(); } } การโทรที่แนะนำจะเป็นเช่นนี้: objects.stream().filter(o -> o instanceof SomeObject).forEach(o -> doSomething()); เว้นแต่ว่าฉันเข้าใจผิดว่าฟังก์ชันการทำงานพื้นฐานของ Stream ทำงานอย่างไรฉันดูเหมือนว่าการใช้ stream เป็นการดำเนินการ O (2n) ซึ่งตรงข้ามกับการดำเนินการ O (n) สำหรับมาตรฐานสำหรับแต่ละลูป

15 java  performance  java8 

var toSizeString = (function() { var KB = 1024.0, MB = 1024 * KB, GB = 1024 * MB; return function(size) { var gbSize = size / GB, gbMod = size % GB, mbSize = gbMod / MB, mbMod = gbMod % MB, kbSize = mbMod / KB; if (Math.floor(gbSize)) …

14 javascript  performance 

คำถาม: ฉันทามติของอุตสาหกรรมซอฟต์แวร์คือรหัสที่สะอาดและเรียบง่ายเป็นพื้นฐานของความมีชีวิตในระยะยาวของฐานรหัสและองค์กรที่เป็นเจ้าของ คุณสมบัติเหล่านี้นำไปสู่การลดค่าใช้จ่ายในการบำรุงรักษาและเพิ่มโอกาสในการสร้างรหัสฐานอย่างต่อเนื่อง อย่างไรก็ตามรหัส SIMD นั้นแตกต่างจากรหัสแอปพลิเคชันทั่วไปและฉันต้องการทราบว่ามีฉันทามติที่คล้ายกันเกี่ยวกับรหัสที่สะอาดและใช้งานง่ายที่ใช้เฉพาะกับรหัส SIMD พื้นหลังคำถามของฉัน ฉันเขียนโค้ด SIMD (คำสั่งคำสั่งเดียวหลายข้อมูล) มากมายสำหรับการประมวลผลภาพและการวิเคราะห์ที่หลากหลาย เมื่อเร็ว ๆ นี้ฉันยังต้องพอร์ตฟังก์ชั่นเหล่านี้จำนวนเล็กน้อยจากสถาปัตยกรรมหนึ่ง (SSE2) ไปยังอีก (ARM NEON) รหัสนี้เขียนขึ้นสำหรับซอฟต์แวร์ที่มีการย่อขนาดดังนั้นจึงไม่สามารถขึ้นอยู่กับภาษาที่เป็นกรรมสิทธิ์หากไม่มีสิทธิ์การแจกจ่ายซ้ำเช่น MATLAB ตัวอย่างของโครงสร้างรหัสทั่วไป: ใช้ประเภทเมทริกซ์ของOpenCV ( Mat)สำหรับการจัดการหน่วยความจำบัฟเฟอร์และอายุการใช้งานทั้งหมด หลังจากตรวจสอบขนาด (ขนาด) ของอาร์กิวเมนต์อินพุตพอยน์เตอร์ไปยังที่อยู่เริ่มต้นของแต่ละแถวของพิกเซลจะถูกนำมาใช้ จำนวนพิกเซลและที่อยู่เริ่มต้นของพิกเซลแต่ละแถวจากเมทริกซ์อินพุตแต่ละอันจะถูกส่งผ่านไปยังฟังก์ชัน C ++ ระดับต่ำ ฟังก์ชัน C ++ ระดับต่ำเหล่านี้ใช้ SIMD ภายใน (สำหรับสถาปัตยกรรม IntelและARM NEON ) โหลดจากและบันทึกไปยังที่อยู่ตัวชี้แบบดิบ ลักษณะของฟังก์ชั่น C ++ ระดับต่ำเหล่านี้: สิทธิพิเศษหนึ่งมิติ (ต่อเนื่องกันในหน่วยความจำ) ไม่จัดการกับการจัดสรรหน่วยความจำ …

14 performance  optimization  estimation 

ในกรณีของรหัสที่คุณต้องทำการล้างทรัพยากรก่อนออกจากฟังก์ชันมีความแตกต่างที่สำคัญระหว่าง 2 วิธีในการทำมัน การทำความสะอาดทรัพยากรก่อนทุกคำสั่งส่งคืน void func() { login(); bool ret = dosomething(); if(ret == false) { logout(); return; } ret = dosomethingelse(); if(ret == false) { logout(); return; } dootherstuff(); logout(); } การทำความสะอาดทรัพยากรในบล็อกสุดท้าย void func() { login(); try { bool ret = dosomething(); if(ret == false) return; ret = dosomethingelse(); …

14 java  performance  efficiency 

พูดว่าฉันมี: interface Thing { GetThing(); } class FastThing : Thing { public int GetThing() { return 1; } } class SlowThing : Thing { public int GetThing() { return GetThingFromDatabase(); } } นี่เป็นการละเมิดหลักการทดแทน Liskov หรือไม่?

14 performance  liskov-substitution 

ในโครงการที่มีข้อกำหนดที่ไม่สามารถใช้งานได้ซึ่งระบุเวลาดำเนินการสูงสุดสำหรับการดำเนินการที่เฉพาะเจาะจง QA จะต้องตรวจสอบประสิทธิภาพของการกระทำนี้บนเครื่องเฉพาะโดยใช้ฮาร์ดแวร์ที่แม่นยำภายใต้ภาระที่แม่นยำทั้งฮาร์ดแวร์และโหลดที่ระบุไว้ในข้อกำหนด ในทางกลับกันการเปลี่ยนแปลงซอร์สโค้ดที่ผิดพลาดบางอย่างอาจส่งผลกระทบอย่างรุนแรงต่อประสิทธิภาพ สังเกตเห็นผลกระทบเชิงลบนี้ในช่วงต้น , ก่อนรหัสที่มาถึงการควบคุมแหล่งที่มาและได้รับการยืนยันโดยแผนก QA, อาจจะเป็นประโยชน์ในแง่ของเวลาที่หายไปโดยแผนก QA รายงานปัญหาและโดยนักพัฒนาแก้ไขมันหลายกระทำในภายหลัง หากต้องการทำสิ่งนี้เป็นความคิดที่ดี: ในการใช้การทดสอบหน่วยเพื่อให้ทราบถึงเวลาที่ใช้ในการดำเนินการแอ็คชั่นเดียวกัน² nครั้ง หากต้องการใช้การหมดเวลาทดสอบต่อหนึ่งครั้งผ่าน[TestMethod, Timeout(200)]แอตทริบิวต์ใน C # ฉันคาดว่าจะมีปัญหาหลายอย่างเกี่ยวกับวิธีการนี้: ตามหลักการแล้วการทดสอบหน่วยไม่ได้สำหรับสิ่งนั้นจริง ๆ พวกเขาคาดหวังว่าจะทดสอบโค้ดเพียงส่วนเล็ก ๆ ไม่มีอะไรเพิ่มเติม: ทั้งการตรวจสอบข้อกำหนดการใช้งานหรือการทดสอบการรวมเข้าด้วยกันหรือการทดสอบประสิทธิภาพ การทดสอบหน่วยหมดเวลาใน Visual Studio วัดจริง ๆ ว่าจะวัดได้หรือไม่โดยคำนึงถึงว่าการเตรียมใช้งานและการล้างข้อมูลนั้นไม่มีอยู่สำหรับการทดสอบเหล่านั้นหรือสั้นเกินไปที่จะส่งผลกระทบต่อผลลัพธ์หรือไม่ การวัดประสิทธิภาพด้วยวิธีนี้น่าเกลียด การใช้เบนช์มาร์กบนเครื่องใด ๆ โดยไม่ขึ้นกับฮาร์ดแวร์โหลด ฯลฯ ก็เหมือนกับการทำเบนช์มาร์กที่แสดงว่าผลิตภัณฑ์ฐานข้อมูลหนึ่งจะเร็วกว่าผลิตภัณฑ์อื่นเสมอ บนมืออื่น ๆ ที่ผมไม่ได้คาดหวังว่าผู้ทดสอบหน่วยที่จะเป็นผลที่ชัดเจนหรือสิ่งที่ถูกใช้โดยแผนก QA การทดสอบหน่วยเหล่านั้นจะถูกนำมาใช้เพียงเพื่อให้ความคิดทั่วไปเกี่ยวกับประสิทธิภาพที่คาดหวังและเป็นหลักในการแจ้งเตือนนักพัฒนาว่าการปรับเปลี่ยนครั้งสุดท้ายของเขายากจนบางสิ่งบางอย่างอย่างรุนแรงส่งผลกระทบต่อประสิทธิภาพการทำงาน การทดสอบการพัฒนาแบบขับเคลื่อน (TDD)เป็นไปไม่ได้สำหรับการทดสอบ ในตอนแรกมันจะล้มเหลวอย่างไรก่อนที่จะเริ่มใช้โค้ด การทดสอบประสิทธิภาพมากเกินไปจะส่งผลต่อเวลาที่ต้องใช้ในการทดสอบดังนั้นวิธีนี้ จำกัด เฉพาะการกระทำสั้น ๆ เท่านั้น …

14 project-management  unit-testing  performance  requirements 

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

14 object-oriented  algorithms  performance 

สมมติว่าฉันกำลังใช้สิ่งที่ง่ายเช่นการค้นหารายการ / แถวลำดับ ฟังก์ชั่น (ใน c #) จะมีลักษณะคล้ายกับ: static int FindIndex(int[] sortedList, int i); ฉันสามารถนำไปใช้และทดสอบสิ่งนี้ในแง่ของฟังก์ชั่น แต่ด้วยเหตุผลที่ชัดเจนฉันมักจะชอบการค้นหาแบบไบนารีมากกว่าการค้นหาเชิงเส้นหรือบางสิ่งที่โง่โดยเจตนา ดังนั้นคำถามของฉันคือ: เราควรพยายามเขียนการทดสอบที่รับประกันประสิทธิภาพในแง่ของความซับซ้อนของอัลกอริทึมและถ้าเป็นเช่นนั้นได้อย่างไร ฉันได้เริ่มสร้างข้อโต้แย้งทั้งสองด้านของ "คุณ" เป็นส่วนหนึ่งของคำถามนี้ แต่ฉันต้องการเห็นสิ่งที่ผู้คนพูดโดยไม่มีข้อโต้แย้งของฉันเพื่อกระตุ้นพวกเขา ในแง่ของ "วิธี" ที่น่าสนใจมาก :) คุณสามารถดูการกำหนดพารามิเตอร์ของตัวดำเนินการเปรียบเทียบและมีการทดสอบซึ่งตัวดำเนินการเปรียบเทียบนั้นนับการเปรียบเทียบหรืออะไรทำนองนั้น แต่เพียงเพราะคุณไม่สามารถหมายความว่าคุณควร ... มีคนอื่นที่คิดว่าสิ่งนี้ (อาจ)? ขอบคุณ

14 performance  unit-testing  testing 

แรงบันดาลใจจากคำถามจาก SO: /programming/6623391/how-to-gain-control-of-a-5gb-heap-in-haskell มันอาจเป็นการถกเถียงกันมานานเกี่ยวกับข้อดีและข้อเสียของ FP มากมาย แต่สำหรับตอนนี้ฉันต้องการ จำกัด ขอบเขตของ FP ที่มีประสิทธิภาพหลักสำหรับฮาร์ดแวร์ที่ทันสมัย วิทยานิพนธ์: กระบวนทัศน์การใช้งานหมายถึงความไม่สามารถเปลี่ยนแปลงได้และไร้สัญชาติ (?) แต่ฮาร์ดแวร์ที่เราเรียกใช้โปรแกรมการทำงานนั้นเป็นสถานะออโตมาต้าอัน จำกัด การแปลโปรแกรม 'ฟังก์ชั่นที่ใช้งานได้จริง' เป็น 'การแสดงสถานะฮาร์ดแวร์' ทำให้การควบคุมเพียงเล็กน้อยสำหรับโปรแกรมเมอร์ทำให้โอเวอร์เฮด (?) และ จำกัด การใช้ความสามารถของฮาร์ดแวร์ ฉันถูกหรือผิดในข้อความที่ถาม? มันสามารถพิสูจน์ได้ว่า FP ทำ / ไม่ได้บอกถึงการลงโทษด้านประสิทธิภาพที่สำคัญของสถาปัตยกรรมคอมพิวเตอร์ที่มีวัตถุประสงค์ทั่วไปที่ทันสมัยหรือไม่? แก้ไข: ตามที่ฉันได้กล่าวแล้วในการตอบสนองต่อความคิดเห็นบางคำถามไม่ได้เกี่ยวกับประสิทธิภาพการใช้งานและรายละเอียด มันเกี่ยวกับการมีอยู่หรือไม่มีค่าโสหุ้ยหลักที่ใช้ FP กับออโตมาตะแบบ stateful อาจนำมาซึ่ง

14 performance  functional-programming  hardware  immutability  state 

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังว่าคำตอบจะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้อาจเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน7 ปีที่ผ่านมา ล็อคแล้ว คำถามและคำตอบของคำถามนี้ถูกล็อคเนื่องจากคำถามอยู่นอกหัวข้อ แต่มีความสำคัญทางประวัติศาสตร์ ขณะนี้ไม่ยอมรับคำตอบหรือการโต้ตอบใหม่ ไม่กี่วันที่ผ่านมาสมาชิกของ StackExchange Anto ได้สอบถามเกี่ยวกับการใช้งานที่ถูกต้องสำหรับตัวดำเนินการบิตที่ชาญฉลาด ฉันระบุว่าการขยับเร็วกว่าการคูณและหารจำนวนเต็มด้วยพลังของสอง Daemin สมาชิก StackExchange โต้กลับโดยระบุว่าการเปลี่ยนทางขวานำเสนอปัญหาด้วยจำนวนลบ ณ จุดนี้ฉันไม่เคยคิดที่จะใช้ตัวดำเนินการ shift กับจำนวนเต็มที่ลงนามแล้ว ฉันใช้เทคนิคนี้เป็นหลักในการพัฒนาซอฟต์แวร์ระดับต่ำ ดังนั้นฉันมักจะใช้จำนวนเต็มไม่ได้ลงนาม C ดำเนินการทางตรรกะกับจำนวนเต็มที่ไม่ได้ลงนาม ไม่มีการจ่ายความสนใจให้กับบิตลงชื่อเมื่อดำเนินการเลื่อนตรรกะอย่างถูกต้อง บิตที่ว่างจะถูกเติมด้วยค่าศูนย์ อย่างไรก็ตาม C ดำเนินการกะการคำนวณทางคณิตศาสตร์เมื่อเลื่อนจำนวนเต็มทางขวาที่ลงนาม บิตที่ว่างจะถูกเติมด้วยบิตเครื่องหมาย ความแตกต่างนี้ทำให้ค่าลบถูกปัดเศษเป็นอนันต์แทนที่จะถูกปัดเศษเป็นศูนย์ซึ่งเป็นพฤติกรรมที่แตกต่างจากการหารจำนวนเต็มที่ลงนามแล้ว ความคิดเพียงไม่กี่นาทีส่งผลให้เกิดโซลูชั่นอันดับหนึ่ง วิธีการแก้ปัญหาแปลงค่าลบให้เป็นค่าบวกก่อนที่จะขยับ ค่าจะถูกแปลงแบบมีเงื่อนไขกลับสู่รูปแบบลบหลังจากดำเนินการกะแล้ว int a = -5; int n = 1; int negative = …

14 c  performance  bitwise-operators 

ฉันอยากจะรู้ว่าอะไรจะเป็นวิธีที่ดีกว่าในการทำให้วัตถุแคช / อัปเดตเป็นโมฆะ ข้อกำหนดเบื้องต้น มีเซิร์ฟเวอร์ memcached ระยะไกล (ทำหน้าที่เป็นแคชสำหรับหลาย ๆ แอปพลิเคชัน) เซิร์ฟเวอร์ทั้งหมดโฮสต์โดย Azure (ภูมิภาคที่สัมพันธ์กัน, ดาต้าเซ็นเตอร์เดียวกัน) ขนาดวัตถุแคชมีตั้งแต่ 200 ไบต์จนถึง 50 กิโลไบต์ วิธีที่ 1 (เก็บในแคชโดยเร็ว) สร้างวัตถุ A -> store ในฐานข้อมูลและเก็บไว้ในแคช วัตถุ A ที่ไคลเอนต์ร้องขอ -> ตรวจสอบแคชเพื่อการมีอยู่ของระบบมิฉะนั้นดึงข้อมูลจากฐานข้อมูลและเก็บไว้ในแคช วัตถุ A รับการอัพเดท -> จัดเก็บในฐานข้อมูลจัดเก็บในแคช วิธีที่ 1 ดูเหมือนจะตรงไปตรงมามากกว่า หากมีการสร้างบางสิ่งให้ใส่แคชโดยเร็ว ไม่ว่าจะมีใครบางคนจะต้องการมัน วิธีที่ 2 (สันหลังยาวแคชสโตร์) สร้างวัตถุ A -> store ในฐานข้อมูลแล้ว …

14 performance  azure  memcached  caching 

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

14 .net  performance  freelancing 

เรามีสถานการณ์ที่ฉันต้องรับมือกับเหตุการณ์ที่ไหลเข้ามาในเซิร์ฟเวอร์ของเราโดยเฉลี่ยประมาณ 1,000 เหตุการณ์ต่อวินาทีโดยเฉลี่ย ปัญหา ระบบของเราโฮสต์บนHerokuและใช้Heroku Postgres DBที่ค่อนข้างแพงซึ่งอนุญาตการเชื่อมต่อ DB ได้สูงสุด 500 เราใช้การเชื่อมต่อร่วมกันเพื่อเชื่อมต่อจากเซิร์ฟเวอร์ไปยังฐานข้อมูล เหตุการณ์เข้ามาเร็วกว่าการเชื่อมต่อฐานข้อมูลที่สามารถจัดการได้ ปัญหาที่เรามีคือเหตุการณ์เกิดขึ้นเร็วกว่าพูลการเชื่อมต่อที่สามารถจัดการได้ เมื่อถึงเวลาที่การเชื่อมต่อหนึ่งเสร็จสิ้นการส่งสัญญาณเครือข่ายจากเซิร์ฟเวอร์ไปยังฐานข้อมูลดังนั้นจึงสามารถปล่อยกลับไปที่กลุ่มได้มากกว่าnมีเหตุการณ์เพิ่มเติมเข้ามา ในที่สุดเหตุการณ์ต่างๆก็หมดลงรอรับการบันทึกและเนื่องจากไม่มีการเชื่อมต่อที่พร้อมใช้งานในกลุ่มจึงหมดเวลาและระบบทั้งหมดไม่สามารถใช้งานได้ เราได้แก้ไขเหตุฉุกเฉินด้วยการปล่อยเหตุการณ์ความถี่สูงที่ก้าวร้าวช้าลงจากลูกค้า แต่เรายังต้องการทราบวิธีจัดการสถานการณ์นี้ในเหตุการณ์ที่เราต้องจัดการกับเหตุการณ์ความถี่สูงนั้น ข้อ จำกัด ลูกค้ารายอื่นอาจต้องการอ่านเหตุการณ์พร้อมกัน ไคลเอนต์อื่น ๆ ร้องขออย่างต่อเนื่องเพื่ออ่านเหตุการณ์ทั้งหมดที่มีคีย์เฉพาะแม้ว่าพวกเขาจะยังไม่ได้บันทึกในฐานข้อมูล ไคลเอนต์สามารถสอบถามGET api/v1/events?clientId=1และรับเหตุการณ์ทั้งหมดที่ส่งโดยไคลเอนต์ 1 แม้ว่าเหตุการณ์เหล่านั้นจะยังไม่ได้ทำการบันทึกในฐานข้อมูล มีตัวอย่าง "ห้องเรียน" เกี่ยวกับวิธีจัดการกับเรื่องนี้หรือไม่? การแก้ปัญหาที่เป็นไปได้ จัดคิวเหตุการณ์บนเซิร์ฟเวอร์ของเรา เราสามารถจัดคิวเหตุการณ์บนเซิร์ฟเวอร์ (ด้วยคิวที่มีการเกิดพร้อมกันสูงสุด 400 เพื่อให้กลุ่มการเชื่อมต่อไม่หมด) นี่เป็นความคิดที่ไม่ดีเพราะ: มันจะกินหน่วยความจำเซิร์ฟเวอร์ที่มีอยู่ เหตุการณ์ที่จัดคิวเข้าด้วยกันจะใช้ RAM จำนวนมาก เซิร์ฟเวอร์ของเราเริ่มต้นใหม่ครั้งเดียวทุก 24 ชั่วโมง นี่เป็นข้อ จำกัด อย่างหนักจาก Heroku เซิร์ฟเวอร์สามารถรีสตาร์ทในขณะที่เหตุการณ์ถูกจัดคิวทำให้เราสูญเสียเหตุการณ์ที่จัดคิว มันแนะนำสถานะบนเซิร์ฟเวอร์จึงทำร้ายความยืดหยุ่น …

13 architecture  performance  scalability  event-sourcing 

ฉันโพสต์คำถามนี้ไว้ใน SO แล้วและก็ใช้ได้ มันน่าเสียดายที่ปิด แต่ (ต้องการเพียงหนึ่งโหวตเพื่อเปิดใหม่) แต่มีคนแนะนำให้ฉันโพสต์ไว้ที่นี่เพราะมันเป็นแบบที่ดีกว่าดังนั้นต่อไปนี้เป็นสำเนาวางคำถามอย่างแท้จริง ฉันอ่านความคิดเห็นเกี่ยวกับคำตอบนี้และฉันเห็นข้อความนี้ การสร้างอินสแตนซ์ของวัตถุและคุณสมบัติเชิงวัตถุนั้นรวดเร็วในการใช้งาน (เร็วกว่า C ++ ในหลาย ๆ กรณี) เพราะพวกมันถูกออกแบบมาตั้งแต่ต้น และคอลเลกชันนั้นรวดเร็ว Java มาตรฐานชนะ C / C ++ มาตรฐานในพื้นที่นี้แม้สำหรับรหัส C ที่ปรับให้เหมาะสมที่สุด ผู้ใช้หนึ่งราย (ที่มีตัวแทนที่สูงมากฉันอาจเพิ่ม) ปกป้องข้อเรียกร้องนี้อย่างกล้าหาญโดยระบุว่า การจัดสรรฮีปใน java ดีกว่าของ C ++ และเพิ่มคำสั่งนี้เพื่อป้องกันการรวบรวมใน java และคอลเลกชัน Java นั้นเร็วกว่าคอลเลกชัน C ++ ซึ่งส่วนใหญ่จะเป็นระบบย่อยหน่วยความจำที่แตกต่างกัน ดังนั้นคำถามของฉันอาจเป็นจริงได้และถ้าเป็นเช่นนั้นเหตุใดการจัดสรรฮีปของ Java จึงเร็วขึ้นมาก

13 java  c++  performance  heap  collections 

ฉันได้ทำการปรับปรุงบางอย่างที่จำเป็นเมื่อเร็ว ๆ นี้ สิ่งหนึ่งที่ฉันทำคือการเปลี่ยน ostringstreams -> sprintfs ฉันกำลังรีบพวงของ std :: strings ไปที่ array style ac, ala char foo[500]; sprintf(foo, "%s+%s", str1.c_str(), str2.c_str()); ปรากฎว่าการใช้งาน std :: string :: c_str () ของ Microsoft นั้นทำงานในเวลาคงที่ (มันแค่คืนค่าตัวชี้ภายใน) ปรากฏว่าlibstdc ++ ไม่เหมือนกัน ฉันรู้ว่ามาตรฐานไม่รับประกันสำหรับ c_str แต่มันยากที่จะจินตนาการถึงวิธีการทำเช่นนี้อีก ตัวอย่างเช่นหากพวกเขาคัดลอกไปยังหน่วยความจำพวกเขาอาจต้องจัดสรรหน่วยความจำสำหรับบัฟเฟอร์ (ปล่อยให้มันขึ้นอยู่กับผู้เรียกที่จะทำลายมัน - ไม่ใช่ส่วนหนึ่งของสัญญา STL) หรือพวกเขาจะต้องคัดลอกไปยังคงที่ภายใน บัฟเฟอร์ (อาจไม่ใช่ threadsafe และคุณไม่มีการรับประกันตลอดอายุการใช้งาน) ดังนั้นเพียงแค่คืนค่าพอยน์เตอร์ไปยังสตริงที่สิ้นสุดด้วยค่า …

13 c++  performance  strings