Malloc vs new - padding ที่แตกต่างกัน

ฉันกำลังตรวจสอบรหัส C ++ ของผู้อื่นสำหรับโครงการของเราที่ใช้ MPI สำหรับการประมวลผลประสิทธิภาพสูง (10 ^ 5 - 10 ^ 6 คอร์) รหัสนี้มีวัตถุประสงค์เพื่อให้สามารถสื่อสารระหว่าง (อาจ) เครื่องจักรที่แตกต่างกันในสถาปัตยกรรมที่แตกต่างกัน เขาเขียนความคิดเห็นที่กล่าวถึงบางสิ่งตามบรรทัดของ:

ปกติเราจะใช้newและdeleteแต่ที่นี่ผมใช้และmalloc freeสิ่งนี้จำเป็นเนื่องจากคอมไพเลอร์บางตัวจะเพิ่มข้อมูลแตกต่างกันเมื่อnewใช้งานซึ่งนำไปสู่ข้อผิดพลาดในการถ่ายโอนข้อมูลระหว่างแพลตฟอร์มต่างๆ mallocนี้ไม่ได้เกิดขึ้นกับ

สิ่งนี้ไม่เข้ากับสิ่งที่ฉันรู้จากคำถามมาตรฐานnewเทียบกับmallocคำถาม

อะไรคือความแตกต่างระหว่าง new / delete และ malloc / free? บอกใบ้ถึงแนวคิดที่ว่าคอมไพเลอร์สามารถคำนวณขนาดของวัตถุได้แตกต่างกัน (แต่เหตุใดจึงแตกต่างจากการใช้sizeof)

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

malloc เข้าใจการจัดตำแหน่งอย่างไร บอกว่าหน่วยความจำได้รับการรับรองว่าจัดวางอย่างถูกต้องnewหรือmallocเป็นสิ่งที่ฉันเคยคิดไว้ก่อนหน้านี้

ฉันเดาว่าเขาวินิจฉัยจุดบกพร่องของตัวเองผิดพลาดในอดีตและอนุมานได้ว่าnewและmallocให้จำนวนช่องว่างที่แตกต่างกันซึ่งฉันคิดว่าอาจไม่เป็นความจริง แต่ฉันไม่พบคำตอบใน Google หรือคำถามก่อนหน้านี้

ช่วยฉันด้วย StackOverflow คุณเป็นความหวังเดียวของฉัน!

IIRC มีจุดที่จู้จี้จุกจิกอย่างหนึ่ง mallocรับประกันว่าจะส่งคืนที่อยู่ที่สอดคล้องกับประเภทมาตรฐานใด ๆ ::operator new(n)รับประกันว่าจะส่งคืนเฉพาะที่อยู่ที่จัดตำแหน่งสำหรับประเภทมาตรฐานใด ๆ ที่มีขนาดไม่เกิน nและหากTไม่ใช่ประเภทอักขระnew T[n]จะต้องส่งคืนที่อยู่ที่จัดตำแหน่งให้Tเท่านั้น

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

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

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

บางทีเขาอาจจะสับสน แต่บางทีรหัสที่เขาพูดถึงเป็นมากกว่าความแตกต่างตรงระหว่างVSmalloc(sizeof(Foo) * n) new Foo[n]อาจจะชอบมากกว่า:

malloc((sizeof(int) + sizeof(char)) * n);

เทียบกับ

struct Foo { int a; char b; }
new Foo[n];

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

เพื่อนร่วมงานของคุณอาจมีnew[]/delete[]คุกกี้วิเศษอยู่ในใจ (นี่คือข้อมูลที่การนำไปใช้งานใช้เมื่อลบอาร์เรย์) อย่างไรก็ตามสิ่งนี้จะไม่มีปัญหาหากมีการใช้การจัดสรรที่เริ่มต้นที่ที่อยู่ที่ส่งกลับnew[]มา (ตรงข้ามกับผู้จัดสรร)

การบรรจุดูมีความเป็นไปได้มากขึ้น การเปลี่ยนแปลงใน ABI อาจส่งผลให้เกิดจำนวนไบต์ต่อท้ายที่แตกต่างกันเพิ่มที่ส่วนท้ายของโครงสร้าง (ซึ่งได้รับอิทธิพลจากการจัดตำแหน่งและพิจารณาอาร์เรย์ด้วย) ด้วย malloc สามารถระบุตำแหน่งของโครงสร้างและทำให้พกพาไปยัง ABI ต่างประเทศได้ง่ายขึ้น โดยปกติรูปแบบเหล่านี้ป้องกันได้โดยการระบุการจัดตำแหน่งและการบรรจุโครงสร้างการถ่ายโอน

รูปแบบของวัตถุที่ไม่สามารถขึ้นอยู่กับว่ามีการจัดสรรการใช้หรือmalloc newทั้งสองส่งกลับตัวชี้ชนิดเดียวกันและเมื่อคุณส่งตัวชี้นี้ไปยังฟังก์ชันอื่นพวกเขาจะไม่ทราบว่าวัตถุนั้นถูกจัดสรรอย่างไร sizeof *ptrขึ้นอยู่กับการประกาศptrไม่ใช่ว่าได้รับมอบหมายอย่างไร

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

เมื่อฉันต้องการที่จะควบคุมรูปแบบของโครงสร้างข้อมูลเก่าธรรมดาของฉันด้วย MS Visual #pragma pack(1)คอมไพเลอร์ใช้ฉัน ผมคิดว่าคำสั่งดังกล่าวได้รับการสนับสนุน precompiler สำหรับคอมไพเลอร์ส่วนใหญ่อย่างเช่นGCC

สิ่งนี้มีผลมาจากการจัดแนวเขตข้อมูลทั้งหมดของโครงสร้างหนึ่งไว้ด้านหลังอีกด้านหนึ่งโดยไม่มีช่องว่าง

หากแพลตฟอร์มในอีกด้านหนึ่งทำเช่นเดียวกัน (กล่าวคือรวบรวมโครงสร้างการแลกเปลี่ยนข้อมูลด้วยช่องว่างภายในเป็น 1) ข้อมูลที่ดึงมาจากทั้งสองด้านก็พอดีกัน ดังนั้นฉันจึงไม่ต้องเล่นกับ malloc ใน C ++

ที่แย่ที่สุดฉันคิดว่าตัวดำเนินการใหม่จะทำงานหนักเกินไปเพื่อที่จะดำเนินการบางอย่างที่ยุ่งยากแทนที่จะใช้ malloc โดยตรงใน C ++

นี่คือการคาดเดาของฉันว่าสิ่งนี้มาจากไหน ดังที่คุณได้กล่าวไปแล้วปัญหาเกิดจากการส่งข้อมูลผ่าน MPI

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

ตัวอย่างเช่นหากคุณต้องการส่ง / รับstd::vector<Foo> Aผ่าน MPI ด้วยเทคนิคดังกล่าวการสมมติว่าขนาดของอาร์เรย์ของอักขระที่เป็นผลลัพธ์นั้นผิดA.size()*sizeof(Foo)โดยทั่วไป กล่าวอีกนัยหนึ่งคือแต่ละคลาสที่ใช้เมธอด serialize / deserialize ควรใช้วิธีที่รายงานขนาดของอาร์เรย์ (หรือดีกว่า แต่เก็บอาร์เรย์ไว้ในคอนเทนเนอร์) นี่อาจเป็นสาเหตุของข้อบกพร่อง อย่างไรก็ตามไม่ทางใดก็ทางหนึ่งที่ไม่มีส่วนเกี่ยวข้องกับnewvs mallocตามที่ระบุไว้ในเธรดนี้

ใน c ++: newคำสำคัญใช้เพื่อจัดสรรไบต์ของหน่วยความจำโดยเฉพาะเกี่ยวกับโครงสร้างข้อมูลบางส่วน ตัวอย่างเช่นคุณได้กำหนดคลาสหรือโครงสร้างบางอย่างและคุณต้องการจัดสรรหน่วยความจำสำหรับอ็อบเจ็กต์

myclass *my = new myclass();

หรือ

int *i = new int(2);

แต่ในทุกกรณีคุณต้องมีประเภทข้อมูลที่กำหนดไว้ (class, struct, union, int, char ฯลฯ ... ) และเฉพาะไบต์ของหน่วยความจำเท่านั้นที่จะได้รับการจัดสรรซึ่งจำเป็นสำหรับอ็อบเจ็กต์ / ตัวแปร (กล่าวคือทวีคูณของประเภทข้อมูลนั้น)

แต่ในกรณีของเมธอด malloc () คุณสามารถจัดสรรหน่วยความจำไบต์ใดก็ได้และคุณไม่จำเป็นต้องระบุประเภทข้อมูลตลอดเวลา ที่นี่คุณสามารถสังเกตได้จาก malloc ():

void *v = malloc(23);

หรือ

void *x = malloc(sizeof(int) * 23);

หรือ

char *c = (char*)malloc(sizeof(char)*35);

malloc เป็นฟังก์ชันประเภทหนึ่งและใหม่เป็นประเภทข้อมูลใน c ++ ใน c ++ หากเราใช้ malloc เกินกว่าที่เราต้องการและควรใช้ typecast มิฉะนั้นคอมไพเลอร์จะให้ข้อผิดพลาดแก่คุณและหากเราใช้ประเภทข้อมูลใหม่ในการจัดสรรหน่วยความจำมากกว่าที่เราไม่ต้องการ เพื่อพิมพ์