ฟังก์ชัน MPI

ประเภทที่ได้รับ การดำเนินการ ประเภทข้อมูล

Bsend Buffer_attach Get_count ANY_SOURCE Sendrecv_replace ANY_TAG โพรบ

Allgetherv Alltoall Alltoallv ลดการสแกน Rduce_scatter

ประเภทที่ได้รับจะถูกสร้างขึ้นจากประเภท MPI ที่กำหนดไว้ล่วงหน้าและประเภทที่ได้รับที่กำหนดไว้ก่อนหน้านี้โดยใช้ฟังก์ชันตัวสร้างพิเศษ

MPI_Type_contiguous, MPI_Type_vector, MPI_Type_hvector, MPI_Type_indexed, MPI_Type_hindexed, MPI_Type_struct

มีการลงทะเบียนชนิดที่ได้รับใหม่โดยการเรียกใช้ฟังก์ชัน MPI_Type_commit หลังจากลงทะเบียนแล้วเท่านั้นจึงจะสามารถใช้ชนิดที่ได้รับมาใหม่ในรูทีนการสื่อสารและในการก่อสร้างประเภทอื่นได้ ประเภท MPI ที่กำหนดไว้ล่วงหน้าจะถือว่าลงทะเบียนแล้ว

เมื่อไม่จำเป็นต้องใช้ประเภทที่ได้รับอีกต่อไป ประเภทนั้นจะถูกทำลายด้วยฟังก์ชัน MPI_Type_free

1) MPI_Init - ฟังก์ชันการเริ่มต้น ผลจากการดำเนินการฟังก์ชันนี้ กลุ่มกระบวนการจะถูกสร้างขึ้นโดยวางกระบวนการแอปพลิเคชันทั้งหมด และสร้างพื้นที่การสื่อสารขึ้น อธิบายโดยเครื่องมือสื่อสาร MPI_COMM_WORLD ที่กำหนดไว้ล่วงหน้า

MPI_Type_commit - การลงทะเบียนประเภท MPI_Type_free - การทำลายประเภท

int MPI_Init(int *argc, ถ่าน ***argv);

2) MPI_Finalize - ฟังก์ชั่นเสร็จสมบูรณ์ โปรแกรม MPI- ฟังก์ชันนี้ปิดกระบวนการ MPI ทั้งหมดและกำจัดพื้นที่การสื่อสารทั้งหมด

int MPI_Finalize (เป็นโมฆะ);

3) ฟังก์ชั่นสำหรับกำหนดจำนวนกระบวนการในพื้นที่การสื่อสาร MPI_Comm_size ฟังก์ชันส่งคืนจำนวนกระบวนการในพื้นที่การสื่อสารของการสื่อสารของตัวสื่อสาร

int MPI_Comm_size(คำสั่ง MPI_Comm, int *size);

4) ฟังก์ชั่นการตรวจจับหมายเลขกระบวนการ MPI_Comm_rank ฟังก์ชันจะส่งกลับจำนวนของกระบวนการที่เรียกว่าฟังก์ชันนี้ หมายเลขกระบวนการอยู่ในช่วง 0..ขนาด-1

int MPI_Comm_rank(คำสั่ง MPI_Comm, int *rank);

5) ฟังก์ชั่นข้อความ MPI_ส่ง ฟังก์ชั่นส่งองค์ประกอบการนับของประเภทข้อมูลข้อความพร้อมแท็กตัวระบุเพื่อประมวลผลปลายทางในพื้นที่การสื่อสารของการสื่อสารสื่อสาร

int MPI_Send (โมฆะ * buf, จำนวน int, ประเภทข้อมูล MPI_Datatype, int dest, แท็ก int, การสื่อสาร MPI_Comm);

6) ฟังก์ชั่นการรับข้อความ MPI_Recv ฟังก์ชั่นรับองค์ประกอบการนับของประเภทข้อมูลข้อความพร้อมแท็กตัวระบุจากกระบวนการต้นทางในพื้นที่การสื่อสารของการสื่อสารสื่อสาร

int MPI_Recv (void* buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Status *status)

7) ฟังก์ชั่นจับเวลา (ตัวจับเวลา) MPI_Wtime ฟังก์ชันส่งคืนเวลาทางดาราศาสตร์เป็นวินาทีที่ผ่านไปนับตั้งแต่จุดใดจุดหนึ่งในอดีต (จุดอ้างอิง)

MPI_Wtime สองเท่า (เป็นโมฆะ)

ฟังก์ชันการส่งข้อความระหว่างกระบวนการแบ่งออกเป็น:

คำนำหน้า S (ซิงโครนัส)

หมายถึงโหมดการถ่ายโอนข้อมูลแบบซิงโครนัส การดำเนินการส่งข้อมูลจะสิ้นสุดเมื่อการรับข้อมูลสิ้นสุดลงเท่านั้น ฟังก์ชันนี้ไม่ใช่แบบท้องถิ่น

คำนำหน้า B (บัฟเฟอร์)

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

คำนำหน้า R (พร้อม)

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

คำนำหน้าฉัน (ทันที)

หมายถึงการดำเนินการที่ไม่ปิดกั้น

โครงสร้าง MPI_สถานะ

หลังจากอ่านข้อความแล้ว อาจไม่ทราบพารามิเตอร์บางอย่าง เช่น จำนวนรายการที่อ่าน รหัสข้อความ และที่อยู่ของผู้ส่ง ข้อมูลนี้สามารถรับได้โดยใช้พารามิเตอร์สถานะ ตัวแปรสถานะจะต้องประกาศอย่างชัดเจนในโปรแกรม MPI ในภาษา C สถานะคือโครงสร้างประเภท MPI_Status โดยมีสามฟิลด์ MPI_SOURCE, MPI_TAG, MPI_ERROR

8) ในการกำหนดจำนวนองค์ประกอบข้อความที่ได้รับจริง คุณต้องใช้ฟังก์ชันพิเศษ MPI_Get_count

int MPI_Get_count (MPI_Status *สถานะ, ประเภทข้อมูล MPI_Datatype, int *count);

9) คุณสามารถกำหนดพารามิเตอร์ของข้อความที่ได้รับโดยไม่ต้องอ่านโดยใช้ฟังก์ชัน MPI_Probe int MPI_Probe (แหล่งที่มา int, แท็ก int, การสื่อสาร MPI_Comm, MPI_Status *สถานะ);

10) ในสถานการณ์ที่คุณต้องปฏิบัติ การแลกเปลี่ยนซึ่งกันและกันข้อมูลระหว่างกระบวนการจะปลอดภัยกว่าหากใช้การดำเนินการแบบรวม MPI_Sendrecv ในการดำเนินการนี้ ข้อมูลที่ส่งจากอาร์เรย์ buf จะถูกแทนที่ด้วยข้อมูลที่ได้รับ

int MPI_Sendrecv (โมฆะ * sendbuf, int sendcount, MPI_Datatype sendtype, int dest, int sendtag, โมฆะ * recvbuf, int recvcount, MPI_Datatype recvtype, แหล่งที่มา int, MPI_Datatype recvtag, MPI_Comm comm, MPI_Status *status);

11) ฟังก์ชั่นสำหรับตรวจสอบความสมบูรณ์ของการดำเนินการ MPI_Test ที่ไม่ปิดกั้น

int MPI_Test (MPI_Request * คำขอ, int * flag, MPI_Status * สถานะ);

นี่เป็นการดำเนินการที่ไม่ปิดกั้นในเครื่อง หากการดำเนินการที่เกี่ยวข้องกับคำขอเสร็จสมบูรณ์แล้ว flag = true จะถูกส่งกลับ และสถานะจะมีข้อมูลเกี่ยวกับการดำเนินการที่เสร็จสมบูรณ์ หากการดำเนินการที่กำลังตรวจสอบไม่เสร็จสมบูรณ์ flag = false จะถูกส่งกลับ และค่าของสถานะจะไม่ถูกกำหนดในกรณีนี้

12) ฟังก์ชั่นสำหรับการยกเลิกคำขอโดยไม่ต้องรอให้ MPI_Request_free การดำเนินการที่ไม่ปิดกั้นเสร็จสิ้น

int MPI_Request_free (MPI_Request * คำขอ);

พารามิเตอร์คำขอถูกตั้งค่าเป็น MPI_REQUEST_NULL

13) การบรรลุการดำเนินการถ่ายโอนข้อมูลจากกระบวนการหนึ่งไปยังกระบวนการทั้งหมดของโปรแกรมอย่างมีประสิทธิภาพ (การเผยแพร่ข้อมูล) สามารถทำได้โดยใช้ฟังก์ชัน MPI:

int MPI_Bcast (โมฆะ *buf,จำนวน int,ประเภท MPI_Datatype,int root,MPI_Comm comm)

ฟังก์ชัน MPI_Bcast ส่งข้อมูลจากบัฟเฟอร์บัฟเฟอร์ที่มีองค์ประกอบการนับ ประเภทประเภทจากกระบวนการที่มีหมายเลขรูทไปจนถึงกระบวนการทั้งหมดที่รวมอยู่ในเครื่องมือสื่อสาร

14) หากคุณต้องการรับข้อความจากใครก็ตามกระบวนการส่งสามารถมีค่า MPI_ANY_SOURCE ที่ระบุสำหรับพารามิเตอร์ต้นทาง

15) หากจำเป็นต้องรับข้อความที่มีแท็กใดๆ คุณสามารถระบุค่าสำหรับพารามิเตอร์แท็กได้ MPI_ANY_TAG

16) พารามิเตอร์สถานะช่วยให้คุณกำหนดคุณสมบัติหลายประการของข้อความที่ได้รับ:

- status.MPI_SOURCE – อันดับกระบวนการส่งข้อความที่ได้รับ

- status.MPI_TAG - แท็กของข้อความที่ได้รับ

17) ฟังก์ชั่น

MPI_Get_coun t(MPI_Status *สถานะ, ประเภท MPI_Datatype, int *count)

ส่งคืนตัวแปรนับจำนวนองค์ประกอบประเภทประเภทในข้อความที่ได้รับ

18) การดำเนินการที่ถ่ายโอนข้อมูลจากกระบวนการทั้งหมดไปยังกระบวนการเดียว ในการดำเนินการครั้งนี้ได้มีการรวบรวม

ค่าดำเนินการประมวลผลข้อมูลอย่างใดอย่างหนึ่ง (เพื่อเน้นจุดสุดท้าย การดำเนินการนี้เรียกอีกอย่างว่าการดำเนินการลดข้อมูล)

int MPI_Reduce (โมฆะ *sendbuf, โมฆะ *recvbuf,จำนวน int,ประเภท MPI_Datatype, MPI_Op op,int root,MPI_Comm comm)

19) การซิงโครไนซ์กระบวนการเช่น มั่นใจได้ถึงความสำเร็จพร้อมกันโดยกระบวนการของจุดหนึ่งของกระบวนการคำนวณโดยใช้ฟังก์ชัน MPI: int MPI_อุปสรรค(MPI_Comm สื่อสาร); ฟังก์ชัน MPI_Barrier กำหนดการดำเนินการแบบรวม ดังนั้น เมื่อใช้แล้ว จะต้องถูกเรียกโดยกระบวนการทั้งหมดของเครื่องมือสื่อสารที่ใช้ เมื่อเรียกใช้ฟังก์ชัน MPI_Barrier

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

20) หากต้องการใช้โหมดการถ่ายโอนแบบบัฟเฟอร์ จะต้องสร้างและถ่ายโอนบัฟเฟอร์หน่วยความจำ MPI

สำหรับการบัฟเฟอร์ข้อความ - ฟังก์ชั่นที่ใช้สำหรับการนี้มีลักษณะดังนี้: int MPI_Buffer_attach (โมฆะ *buf, ขนาด int),

- บัฟเฟอร์หน่วยความจำ buf สำหรับการบัฟเฟอร์ข้อความ

- ขนาด – ขนาดบัฟเฟอร์

21) หลังจากทำงานกับบัฟเฟอร์เสร็จแล้วจะต้องตัดการเชื่อมต่อจาก MPI โดยใช้ฟังก์ชัน:

int MPI_Buffer_detach (โมฆะ *buf, int *size)

22) การดำเนินการรับส่งข้อมูลพร้อมกันมีประสิทธิภาพและรับประกันได้โดยใช้ฟังก์ชัน MPI:

int MPI_Sendrecv (โมฆะ *sbuf,int scount,MPI_Datatype stype,int dest, int stag, โมฆะ *rbuf,int rcount,MPI_Datatype

rtype, int source, int rtag, การสื่อสาร MPI_Comm, MPI_Status *สถานะ)

23) เมื่อข้อความเป็นประเภทเดียวกัน MPI จะสามารถใช้งานได้ บัฟเฟอร์เดียว: intMPI_Sendrecv_replace (เป็นโมฆะ *buf, จำนวน int, ประเภท MPI_Datatype, int dest,

int stag, int source, int rtag, การสื่อสาร MPI_Comm, สถานะ MPI_Status*)

24) การดำเนินการทั่วไปของการส่งข้อมูลจากกระบวนการหนึ่งไปยังกระบวนการทั้งหมด (การกระจายข้อมูล) แตกต่างจากการออกอากาศตรงที่กระบวนการส่งข้อมูลที่แตกต่างกันไปยังกระบวนการ (ดูรูปที่ 4.4) การดำเนินการนี้สามารถทำได้โดยใช้ฟังก์ชัน:

int MPI_Scatter (โมฆะ *sbuf,int scount,MPI_Datatype stype,

25) การดำเนินการถ่ายโอนข้อมูลทั่วไปจากโปรเซสเซอร์ทั้งหมดไปยังกระบวนการเดียว (การรวบรวมข้อมูล) เป็นสิ่งที่ตรงกันข้ามกับขั้นตอนการกระจายข้อมูล (ดูรูปที่ 4.5) ในการดำเนินการนี้ใน MPI มีฟังก์ชัน:

int MPI_Gather (โมฆะ *sbuf,int scount,MPI_Datatype stype,

เป็นโมฆะ *rbuf,int rcount,MPI_Datatype rtype, int root, MPI_Comm comm)

26) ควรสังเกตว่าเมื่อใช้ฟังก์ชัน MPI_Gather การรวบรวมข้อมูลจะดำเนินการเท่านั้น

ในกระบวนการเดียว เพื่อรับข้อมูลที่รวบรวมทั้งหมดในแต่ละกระบวนการสื่อสาร

คุณต้องใช้ฟังก์ชันการรวบรวมและการแจกจ่าย:

int MPI_Allgather (โมฆะ *sbuf, int scount, MPI_Datatype stype, โมฆะ *rbuf, int rcount, MPI_Datatype rtype, MPI_Comm comm)

27) การถ่ายโอนข้อมูลจากกระบวนการทั้งหมดไปยังกระบวนการทั้งหมดเป็นการดำเนินการถ่ายโอนข้อมูลที่พบบ่อยที่สุด (ดูรูปที่ 4.6) การดำเนินการนี้สามารถทำได้โดยใช้ฟังก์ชัน:

int MPI_Alltoall (โมฆะ *sbuf,int scount,MPI_Datatype stype, โมฆะ *rbuf,int rcount,MPI_Datatype rtype,MPI_Comm comm)

28) ฟังก์ชัน MPI_Reduce ให้ผลลัพธ์การลดข้อมูล

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

int MPI_Allreduce (โมฆะ *sendbuf, โมฆะ *recvbuf,จำนวน int,ประเภท MPI_Datatype, MPI_Op op,MPI_Comm comm)

29) และการดำเนินการรวบรวมและประมวลผลข้อมูลเวอร์ชันอื่นซึ่งช่วยให้มั่นใจได้ว่าจะได้รับผลลัพธ์การลดบางส่วนทั้งหมดสามารถรับได้โดยใช้ฟังก์ชัน:

int MPI_Scan (โมฆะ *sendbuf, โมฆะ *recvbuf,จำนวน int,ประเภท MPI_Datatype, MPI_Op op,MPI_Comm comm)

แผนภาพการทำงานทั่วไปของฟังก์ชัน MPI_Scan แสดงในรูปที่ 1 4.7. องค์ประกอบของข้อความที่ได้รับแสดงถึงผลลัพธ์ของการประมวลผลองค์ประกอบที่สอดคล้องกันของข้อความที่ส่งโดยกระบวนการ และเพื่อให้ได้ผลลัพธ์ในกระบวนการที่มีอันดับ i, 0≤i

30) ค่าเริ่มต้นของตัวแปร bufpos ต้องถูกสร้างขึ้นก่อนที่บรรจุภัณฑ์จะเริ่มต้น จากนั้นจะถูกตั้งค่าโดยฟังก์ชัน MPI_แพ็ค ฟังก์ชัน MPI_Pack ถูกเรียกตามลำดับเพื่อแพ็คข้อมูลที่จำเป็นทั้งหมด

int MPI_Pack_size (จำนวน int, ประเภท MPI_Datatype, คำสั่ง MPI_Comm, int *size)

31) หลังจากบรรจุข้อมูลที่จำเป็นทั้งหมดแล้ว สามารถใช้บัฟเฟอร์ที่เตรียมไว้ในฟังก์ชันการถ่ายโอนข้อมูลตามประเภท MPI_PACKED ที่ระบุ

หลังจากได้รับข้อความประเภท MPI_PACKED ข้อมูลสามารถแตกได้โดยใช้ฟังก์ชัน:

int MPI_Unpack (เป็นโมฆะ *buf, int bufsize, int *bufpos, โมฆะ *data, จำนวน int, ประเภท MPI_Datatype, การสื่อสาร MPI_Comm)

คอมพิวเตอร์ชุดคำสั่งที่ซับซ้อน

CISC (คอมพิวเตอร์ชุดคำสั่งภาษาอังกฤษที่ซับซ้อน หรือคอมพิวเตอร์ชุดคำสั่งภาษาอังกฤษที่ซับซ้อน -

คอมพิวเตอร์พร้อมชุดคำสั่งครบชุด) เป็นแนวคิดการออกแบบโปรเซสเซอร์ที่มีลักษณะเฉพาะด้วยชุดคุณสมบัติดังต่อไปนี้:

มีการลงทะเบียนวัตถุประสงค์ทั่วไปจำนวนค่อนข้างน้อย

· คำสั่งเครื่องจำนวนมากซึ่งบางส่วนโหลดเชิงความหมายคล้ายกับตัวดำเนินการของภาษาการเขียนโปรแกรมระดับสูงและดำเนินการในรอบสัญญาณนาฬิกาหลายรอบ

· วิธีการระบุที่อยู่จำนวนมาก

· รูปแบบคำสั่งจำนวนมากที่มีขนาดบิตต่างๆ

· ความเด่นของรูปแบบคำสั่งสองที่อยู่

· การมีคำสั่งการประมวลผลประเภทลงทะเบียนหน่วยความจำ

ข้อบกพร่อง :

ฮาร์ดแวร์ราคาสูง ความยากลำบากในการคำนวณแบบขนาน

เทคนิคการสร้างระบบคำสั่ง CISC ตรงกันข้ามกับเทคนิคอื่น - RISC ความแตกต่างระหว่างแนวคิดเหล่านี้อยู่ที่วิธีการเขียนโปรแกรม ไม่ใช่ในสถาปัตยกรรมตัวประมวลผลจริง โปรเซสเซอร์สมัยใหม่เกือบทั้งหมดจำลองชุดคำสั่งประเภท RISC และ CISC

ลดชุดคำสั่งคอมพิวเตอร์

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

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

และ รูปแบบคงที่

ใน เทคโนโลยีบัฟเฟอร์ที่อยู่เป้าหมายการเปลี่ยนแปลงมีจุดประสงค์อะไร?

ใน โปรเซสเซอร์มีกลไกในการทำนายทิศทางการเปลี่ยนแปลงแบบไดนามิก ด้วยสิ่งนี้

เป้าหมายบนชิปคือหน่วยความจำแคชขนาดเล็กที่เรียกว่า Branch Target Buffer (BTB) และบัฟเฟอร์การดึงคำสั่งล่วงหน้าสองคู่ที่เป็นอิสระ (บัฟเฟอร์ 32 บิตสองตัวต่อไปป์ไลน์) บัฟเฟอร์ที่อยู่เป้าหมายสาขาจะจัดเก็บที่อยู่ของคำสั่งที่อยู่ในบัฟเฟอร์การดึงข้อมูลล่วงหน้า การดำเนินการของบัฟเฟอร์การดึงข้อมูลล่วงหน้าได้รับการจัดระเบียบในลักษณะที่ในเวลาที่กำหนด คำแนะนำจะถูกดึงเข้าในบัฟเฟอร์ตัวใดตัวหนึ่งของคู่ที่เกี่ยวข้องเท่านั้น เมื่อตรวจพบการดำเนินการสาขาในสตรีมคำสั่ง ที่อยู่สาขาที่คำนวณแล้วจะถูกเปรียบเทียบกับที่อยู่ที่จัดเก็บไว้ใน BTB หากมีการจับคู่กัน ระบบคาดการณ์ว่าสาขาจะเกิดขึ้นและบัฟเฟอร์การดึงข้อมูลล่วงหน้าอื่นถูกเปิดใช้งาน และเริ่มออกคำสั่งไปยังไปป์ไลน์ที่เกี่ยวข้องเพื่อดำเนินการ หากมีข้อมูลไม่ตรงกัน ระบบจะถือว่าสาขาจะไม่ถูกดำเนินการและไม่มีการสลับบัฟเฟอร์การดึงข้อมูลล่วงหน้า โดยดำเนินการตามคำสั่งปกติต่อไป ซึ่งจะช่วยหลีกเลี่ยงการหยุดทำงานของสายพานลำเลียง

ความขัดแย้งทางโครงสร้างและวิธีการลดความขัดแย้ง

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

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

การย่อขนาด: ไปป์ไลน์จะหยุดการทำงานของคำสั่งใดคำสั่งหนึ่งชั่วคราวจนกว่าอุปกรณ์ที่ต้องการจะพร้อมใช้งาน

ข้อขัดแย้งของข้อมูล การหยุดไปป์ไลน์ และการนำกลไกบายพาสไปใช้

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

ข้อขัดแย้งของข้อมูลทำให้ไปป์ไลน์หยุดชั่วคราว

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

บัฟเฟอร์การทำนายสาขาแบบมีเงื่อนไข

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

บังเอิญว่าฉันได้พบปะอย่างใกล้ชิดกับการศึกษาเกี่ยวกับการประมวลผลแบบขนานและโดยเฉพาะอย่างยิ่ง MPI บางทีทิศทางนี้อาจมีแนวโน้มมากในวันนี้ ดังนั้นฉันอยากจะแสดงให้ผู้ใช้ฮับเบราว์เซอร์เห็นถึงพื้นฐานของกระบวนการนี้

หลักการพื้นฐานและตัวอย่าง

การคำนวณเลขชี้กำลัง (e) จะใช้เป็นตัวอย่าง หนึ่งในตัวเลือกในการค้นหาคือซีรี่ส์ Taylor:
อี^x=∑((x^n)/n!)โดยที่ผลรวมเกิดขึ้นจาก n=0 ถึงอนันต์

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

จำนวนคำศัพท์ที่จะคำนวณในตัวประมวลผลแต่ละตัวนั้นขึ้นอยู่กับความยาวของช่วงเวลา n และจำนวนตัวประมวลผล k ที่มีอยู่ที่สามารถเข้าร่วมในกระบวนการคำนวณได้ ตัวอย่างเช่น หากความยาวของช่วงเวลาคือ n=4 และมีตัวประมวลผลห้าตัว (k=5) มีส่วนร่วมในการคำนวณ ดังนั้นตัวประมวลผลตัวแรกถึงตัวที่สี่จะได้รับหนึ่งเทอมต่อตัว และตัวประมวลผลที่ห้าจะไม่ถูกใช้ หาก n=10 และ k=5 โปรเซสเซอร์แต่ละตัวจะได้รับเงื่อนไขในการคำนวณสองเงื่อนไข

เริ่มแรก โปรเซสเซอร์ตัวแรกที่ใช้ฟังก์ชันการออกอากาศ MPI_Bcast จะส่งค่าของตัวแปร n ที่ผู้ใช้ระบุไปให้ตัวอื่น โดยทั่วไป ฟังก์ชัน MPI_Bcast จะมีรูปแบบดังต่อไปนี้:
int MPI_Bcast(void *buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm) โดยที่ buffer คือที่อยู่ของบัฟเฟอร์ที่มีองค์ประกอบ count คือจำนวนขององค์ประกอบ ประเภทข้อมูลคือประเภทข้อมูลที่สอดคล้องกันใน MPI root คือ อันดับของโปรเซสเซอร์หลักที่จัดการการส่งต่อ และ comm คือชื่อของเครื่องมือสื่อสาร
ในกรณีของฉัน บทบาทของโปรเซสเซอร์หลักดังที่กล่าวไปแล้ว จะเป็นโปรเซสเซอร์ตัวแรกที่มีอันดับ 0

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

ในระหว่างการดำเนินการตามรอบ ข้อกำหนดจะถูกเพิ่มลงในตัวแปรแยกต่างหาก และหลังจากเสร็จสิ้น จำนวนผลลัพธ์จะถูกส่งไปยังผู้ประมวลผลหลัก เมื่อต้องการทำเช่นนี้ ฟังก์ชันการดำเนินการลด MPI_Reduce จะถูกนำมาใช้ โดยทั่วไปจะมีลักษณะดังนี้:
int MPI_Reduce (เป็นโมฆะ *buf, โมฆะ *ผลลัพธ์, จำนวน int, ประเภทข้อมูล MPI_Datatype, MPI_Op op, int root, การสื่อสาร MPI_Comm)

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

หลังจากรันโปรแกรมบนโปรเซสเซอร์ทั้งหมดแล้ว โปรเซสเซอร์ตัวแรกจะได้รับผลรวมของคำศัพท์ ซึ่งจะเป็นค่าเลขชี้กำลังที่เราต้องการ

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

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

อัลกอริทึมการดำเนินการโค้ด

1. ค่าของตัวเลข n จะถูกถ่ายโอนจากวิชวลเชลล์ไปยังโปรแกรม ซึ่งจะถูกส่งไปยังโปรเซสเซอร์ทั้งหมดโดยใช้ฟังก์ชันการออกอากาศ
2. เมื่อเตรียมใช้งานโปรเซสเซอร์หลักตัวแรก ตัวจับเวลาจะเริ่มต้นขึ้น
3. โปรเซสเซอร์แต่ละตัวดำเนินการแบบวนซ้ำ โดยที่ค่าที่เพิ่มขึ้นคือจำนวนโปรเซสเซอร์ในระบบ ในการวนซ้ำแต่ละครั้ง คำศัพท์จะถูกคำนวณและผลรวมของคำศัพท์ดังกล่าวจะถูกเก็บไว้ในตัวแปร drobSum
4. หลังจากการวนซ้ำเสร็จสิ้น โปรเซสเซอร์แต่ละตัวจะเพิ่มค่า drobSum ให้กับตัวแปร Result โดยใช้ฟังก์ชันลด MPI_Reduce
5. หลังจากเสร็จสิ้นการคำนวณบนโปรเซสเซอร์ทั้งหมดแล้ว โปรเซสเซอร์หลักตัวแรกจะหยุดการจับเวลาและส่งค่าผลลัพธ์ของตัวแปร Result ไปยังเอาท์พุตสตรีม
6. ค่าเวลาที่วัดโดยตัวจับเวลาของเราในหน่วยมิลลิวินาทีจะถูกส่งไปยังสตรีมเอาท์พุตด้วย

รายการรหัส

โปรแกรมเขียนด้วยภาษา C ++ เราจะถือว่าอาร์กิวเมนต์สำหรับการดำเนินการถูกส่งผ่านจากเชลล์ภายนอก รหัสมีลักษณะดังนี้:

#รวม "mpi.h"
#รวม
#รวม
ใช้เนมสเปซมาตรฐาน;

ข้อเท็จจริงสองเท่า (int n)
{
ถ้า (n==0)
กลับ 1;
อื่น
กลับ n*Fact(n-1);
}

int หลัก (int argc, ถ่าน * argv)
{
SetConsoleOutputCP (1251);
อินท์เอ็น;
อินท์มายด์;
int numprocs;
ฉัน;
int rc;
long double drob,drobSum=0,ผลลัพธ์,ผลรวม;
เวลาเริ่มต้นสองเท่า = 0.0;
เวลาสิ้นสุดสองครั้ง;

N = อาตอย(argv);

ถ้า (rc= MPI_Init(&argc, &argv))
{
ศาล<< "ข้อผิดพลาดในการเริ่มต้น การดำเนินการหยุดลง" << endl;
MPI_ยกเลิก(MPI_COMM_WORLD, rc);
}

MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&myid);

ถ้า (มายไอดี == 0)
{

เวลาเริ่มต้น = MPI_Wtime();
}
MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);

สำหรับ (i = myid; i<= n; i += numprocs)
{
หยด = 1/ข้อเท็จจริง(i);
drobSum += หยด;
}

MPI_Reduce(&drobSum, &ผลลัพธ์, 1, MPI_LONG_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
cout.ความแม่นยำ (20);
ถ้า (มายไอดี == 0)
{
ศาล<< Result << endl;
เวลาสิ้นสุด = MPI_Wtime();
ศาล<< (endwtime-startwtime)*1000 << endl;
}

MPI_สรุป();
กลับ 0;
}

* ซอร์สโค้ดนี้ถูกเน้นด้วย Source Code Highlighter

บทสรุป

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

หมายเหตุนี้แสดงวิธีการติดตั้ง MPI เชื่อมต่อกับ Visual Studio จากนั้นใช้กับพารามิเตอร์ที่ระบุ (จำนวนโหนดประมวลผล) บทความนี้ใช้ Visual Studio 2015 เนื่องจาก... นี่คือสิ่งที่นักเรียนของฉันมีปัญหา (บันทึกนี้เขียนโดยนักเรียนสำหรับนักเรียน) แต่คำแนะนำอาจจะใช้ได้กับเวอร์ชันอื่นเช่นกัน

ขั้นตอนที่ 1:
คุณต้องติดตั้ง HPC Pack 2008 SDK SP2 (ในกรณีของคุณอาจมีเวอร์ชันอื่นอยู่แล้ว) ซึ่งมีอยู่ในเว็บไซต์ Microsoft อย่างเป็นทางการ ความจุบิตของแพ็คเกจและระบบต้องตรงกัน

ขั้นตอนที่ 2:
คุณต้องกำหนดค่าเส้นทาง โดยไปที่แท็บ Debug - Properties:

“C:\Program Files\Microsoft HPC Pack 2008 SDK\Include”

ในฟิลด์ Library Directories:

“C:\Program Files\Microsoft HPC Pack 2008 SDK\Lib\amd64”

ในช่องไลบรารี หากมีเวอร์ชัน 32 บิต คุณต้องป้อน i386 แทน amd64

Msmpi.lib

:

ขั้นตอนที่ 3:

ในการกำหนดค่าการเปิดตัว คุณต้องไปที่แท็บ Debugging และในช่อง Command ให้ระบุ:

“C:\Program Files\Microsoft HPC Pack 2008 SDK\Bin\mpiexec.exe”

ในฟิลด์ Command Arguments ให้ระบุ เช่น

N 4 $(เส้นทางเป้าหมาย)

หมายเลข 4 ระบุจำนวนกระบวนการ

ในการรันโปรแกรมคุณต้องเชื่อมต่อไลบรารี

เส้นทางไปยังโครงการต้องไม่มีอักษรซีริลลิก หากเกิดข้อผิดพลาด คุณสามารถใช้ Microsoft MPI ได้จากเว็บไซต์ Microsoft

ในการดำเนินการนี้หลังการติดตั้ง เพียงป้อนเส้นทางในช่องคำสั่งของแท็บการดีบัก:

“C:\Program Files\Microsoft MPI\Bin\mpiexec.exe”

นอกจากนี้ก่อนที่จะรันโปรแกรมอย่าลืมระบุความลึกของบิต:

ตัวอย่างการรันโปรแกรมด้วย MPI:

#รวม #รวม ใช้เนมสเปซมาตรฐาน; int main(int argc, char **argv) ( int rank, size; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); cout<< "The number of processes: " << size << " my number is " << rank << endl; MPI_Finalize(); return 0; }

การรันโปรแกรมบน 2 โหนด:

การเรียกใช้แอปพลิเคชัน MPI บนคลัสเตอร์การประมวลผลสามารถทำได้ผ่านระบบประมวลผลงานแบบแบตช์เท่านั้น เพื่อให้การเปิดและการเข้าคิวโปรแกรมแบบขนานง่ายขึ้น จะมีการจัดเตรียมสคริปต์ mpirun พิเศษไว้ ตัวอย่างเช่น mpirun -np 20 ./first.exe จะรันโปรแกรมแบบขนาน first.exe บนโปรเซสเซอร์ 20 ตัว เช่น ที่ 5 โหนด (แต่ละโหนดมีโปรเซสเซอร์ดูอัลคอร์ 2 ตัว) เป็นที่น่าสังเกตว่าในการเปิดโมดูลปฏิบัติการที่อยู่ในไดเร็กทอรีปัจจุบัน ($pwd) คุณต้องระบุเส้นทาง “./” อย่างชัดเจน การใช้งาน MPI-1 จำนวนหนึ่งจะมีคำสั่งเรียกใช้งานสำหรับโปรแกรม MPI ซึ่งมีรูปแบบ เอ็มไพรุน<аргументы mpirun><программа><аргументы программы>

การแยกคำสั่งเรียกใช้โปรแกรมออกจากตัวโปรแกรมเองทำให้เกิดความยืดหยุ่น โดยเฉพาะสำหรับการใช้งานแบบเครือข่ายและแบบต่างกัน การมีกลไกการเปิดตัวมาตรฐานยังช่วยขยายความสามารถในการพกพาของโปรแกรม MPI ไปอีกขั้นหนึ่งไปยังบรรทัดคำสั่งและสคริปต์ที่จัดการพวกมัน ตัวอย่างเช่น สคริปต์สำหรับชุดโปรแกรมตรวจสอบความถูกต้องที่รันโปรแกรมหลายร้อยโปรแกรมอาจเป็นสคริปต์แบบพกพาได้หากเขียนโดยใช้กลไกการเรียกใช้มาตรฐานดังกล่าว เพื่อไม่ให้สับสนระหว่างคำสั่ง ``มาตรฐาน'' กับคำสั่งที่มีอยู่ในทางปฏิบัติ ซึ่งไม่ใช่มาตรฐานและไม่สามารถพกพาได้ในการใช้งาน MPI จึงกำหนด mpiexec แทน mpirun

แม้ว่ากลไกการเปิดตัวที่เป็นมาตรฐานจะปรับปรุงการใช้งาน MPI แต่ช่วงของสภาพแวดล้อมก็มีความหลากหลายมาก (เช่น อาจไม่มีอินเทอร์เฟซบรรทัดคำสั่งด้วยซ้ำ) ซึ่ง MPI ไม่สามารถกำหนดกลไกดังกล่าวได้ MPI จะกำหนดคำสั่งรัน mpiexec แทน และแนะนำแต่ไม่จำเป็นต้องใช้เพื่อเป็นคำแนะนำสำหรับนักพัฒนา อย่างไรก็ตาม หากการใช้งานมีคำสั่งที่เรียกว่า mpiexec จะต้องอยู่ในรูปแบบที่อธิบายไว้ด้านล่าง: mpiexec -n <программа>

จะมีอย่างน้อยหนึ่งวิธีในการวิ่ง<программу>ด้วย MPI_COMM_WORLD เริ่มต้นซึ่งมีกลุ่มประกอบด้วย กระบวนการ อาร์กิวเมนต์อื่น ๆ ของ mpiexec อาจขึ้นอยู่กับการใช้งาน

ตัวอย่าง 4.1 การรัน myprog 16 อินสแตนซ์บนเครื่องปัจจุบันหรือเครื่องเริ่มต้น:

mpiexec -n 16 myprog

3. เขียนโปรแกรมสำหรับการคำนวณอินทิกรัลจำกัดของฟังก์ชัน 2*(x+2*x*x/1200.0) แบบขนานในช่วงเวลา

วิธีสี่เหลี่ยมผืนผ้าซ้าย

ดับเบิ้ลเอฟ(ดับเบิ้ล x)

(ส่งคืน 2*(x+2*x*x/1200);) // iskomyi integrated

int หลัก (int argc, ถ่าน ** argv)

สถานะ MPI_สถานะ;

MPI_Init(&argc,&argv);

MPI_Comm_rank(MPI_COMM_WORLD,&อันดับ);

MPI_Comm_size(MPI_COMM_WORLD,&ขนาด);

int n=1,000,i,d; // 1,000 - อุซซี่

ลอย a=0, b=1, h=(b-a)/n,s=0,r=0; //a ฉัน b -nachalo และ konec otrezka

if (rank!=size-1) // schitaut vse processy, krome poslednego

( สำหรับ (i=rank*d; i<(rank+1)*d; i++) { s=s+h*f(a+i*h); }

MPI_Send(&s,1,MPI_FLOAT,ขนาด-1,1,MPI_COMM_WORLD);)

( สำหรับ (i=0; i

( MPI_Recv(&s,1,MPI_FLOAT,i,1,MPI_COMM_WORLD, &สถานะ); r+=s; ) )

MPI_สรุป();)

สุรักษ์

1- สถาปัตยกรรมหน่วยความจำแบบแบ่งใช้และแบบกระจาย

หน่วยความจำที่ใช้ร่วมกันแบบกระจาย (DSM)

ตามเนื้อผ้า การคำนวณแบบกระจายจะขึ้นอยู่กับรูปแบบการส่งข้อความ ซึ่งข้อมูลจะถูกส่งผ่านจากตัวประมวลผลไปยังตัวประมวลผลในรูปแบบของข้อความ การเรียกขั้นตอนระยะไกลจริง ๆ แล้วเป็นรุ่นเดียวกัน (หรือใกล้เคียงกันมาก) DSM คือพื้นที่ที่อยู่เสมือนที่ใช้ร่วมกันโดยโหนด (โปรเซสเซอร์) ทั้งหมดของระบบแบบกระจาย โปรแกรมเข้าถึงข้อมูลใน DSM ในลักษณะเดียวกับการเข้าถึงข้อมูลในหน่วยความจำเสมือนของคอมพิวเตอร์แบบดั้งเดิม ในระบบที่มี DSM ข้อมูลจะย้ายระหว่างหน่วยความจำในเครื่องของคอมพิวเตอร์เครื่องต่างๆ ในลักษณะเดียวกับที่ย้ายระหว่าง RAM และหน่วยความจำภายนอกของคอมพิวเตอร์เครื่องหนึ่ง การกำหนดค่าหน่วยความจำที่ใช้ร่วมกันแบบกระจายเป็นรูปแบบหนึ่งของหน่วยความจำแบบกระจาย ในที่นี้ โหนดทั้งหมดซึ่งประกอบด้วยโปรเซสเซอร์ตั้งแต่หนึ่งตัวขึ้นไปที่เชื่อมต่อผ่านโครงร่าง SMP จะใช้พื้นที่ที่อยู่ทั่วไป ความแตกต่างระหว่างการกำหนดค่านี้กับเครื่องที่มีหน่วยความจำแบบกระจายก็คือ โปรเซสเซอร์ใดๆ ในที่นี้สามารถเข้าถึงส่วนใดๆ ของหน่วยความจำได้ อย่างไรก็ตาม เวลาในการเข้าถึงสำหรับส่วนหน่วยความจำที่แตกต่างกันจะแตกต่างกันไปสำหรับโปรเซสเซอร์แต่ละตัว ขึ้นอยู่กับตำแหน่งของส่วนนั้นในคลัสเตอร์ ด้วยเหตุนี้ การกำหนดค่าดังกล่าวจึงเรียกว่าเครื่องที่มีการเข้าถึงหน่วยความจำที่ไม่สม่ำเสมอ (NUMA)

ความแตกต่างระหว่าง MPI และ PVM

ระบบ PVM (Parallel Virtual Machine) ถูกสร้างขึ้นเพื่อรวมเวิร์กสเตชันในเครือข่ายหลายเครื่องไว้ในเครื่องประมวลผลเสมือนแบบขนานเครื่องเดียว ระบบนี้เป็นส่วนเสริมของระบบปฏิบัติการ UNIX และใช้กับแพลตฟอร์มฮาร์ดแวร์ต่างๆ รวมถึงระบบขนานขนาดใหญ่ ระบบการเขียนโปรแกรมแบบขนานที่พบมากที่สุดในปัจจุบันใช้ MPI (Message Parsing Interface) แนวคิดของ MPI ในตอนแรกนั้นเรียบง่ายและชัดเจน มันเกี่ยวข้องกับการเป็นตัวแทนของโปรแกรมแบบขนานเป็นชุดของกระบวนการดำเนินการแบบขนานที่โต้ตอบซึ่งกันและกันระหว่างการดำเนินการถ่ายโอนข้อมูลโดยใช้ขั้นตอนการสื่อสาร พวกเขาประกอบขึ้นเป็นไลบรารี MPI อย่างไรก็ตาม การใช้งาน MPI อย่างเหมาะสมเพื่อรองรับการสื่อสารระหว่างโปรเซสเซอร์ได้รับการพิสูจน์แล้วว่าค่อนข้างยาก ความซับซ้อนนี้เกี่ยวข้องกับความจำเป็นในการบรรลุประสิทธิภาพของโปรแกรมที่สูง ความต้องการใช้ทรัพยากรคอมพิวเตอร์หลายเครื่องจำนวนมาก และผลที่ตามมาคือ ความหลากหลายอย่างมากในการใช้ขั้นตอนการสื่อสาร ขึ้นอยู่กับโหมดการประมวลผลข้อมูล