processors. Its address range is fr

processors. Its address range is from 0x0000000 to 0xefffffff
while the address range of both local memories is from
0xf0000000 to 0xffffffff. By default, the application will be
loaded at shared memory. The full memory map for each
processor is mapped into the shared memory object except for
a small section of local memory for each stack. So, the
icmLoadProcessorMemory() function is used once for one of
processors. By this way, the application is loaded on the shared
memory from which both processors will execute the same
main code and each processor executes its tasks. Tasks can be
dependent or independent.
As the shared memory is connected at the address 0, we
should use flags for the synchronization between the different
processors. Besides, the scheduler of the OVPsim begins by the
processor having the upper identifier. So, to get the execution
order that suits our application, the flags are the solution. To
divide jobs between processors, we use the impProcessorId()
call which is an Imperas function used to identify processor.
B. Shared memory at a particular bus’s adress

Instead of connecting the shared memory at the first
address: 0x00000000, it can be connected at any address that
belongs to the bus address range provided that it is not mapped
or used by other components.
We define an architecture composed of two processors
connected to a shared memory with an address range from
0x80000000 to 0xffffffff.Each processor has its local memory
mapped from 0x00000000 to 0x7fffffff. The application is
loaded in the local memory as it is connected at the address
0x00000000. We should have two application files which are s
loaded in the local memory of each processor. The shared
address has to be visible for both processors. In order to
successfully exploit the shared memory, we use the algorithm
of Peterson for mutual exclusion. This algorithm allows two
processes to share a single-use resource without conflict based
on a shared memory for communication. Two processes can
never be in the critical section at the same time.
C. Shared memory and Linux
For the communication between different processors
booting an OS (Linux in our case), the use of the shared
memory remains a valid solution. We use the memory mapped
files which enable several processes to map the same file and
the interaction between them. The mmap() function offers this
service.
In case of a multiprocessor architecture, where processors
boot Linux, we should include the header: #include
in order to use of the mmap() function in our
application which is cross-compiled for a target,. The mapping
is from the address space of the process to the object
represented by the file descriptor as it is shown in Figure 1.
This file descriptor (fd), should be instantiated as following:
fd = open("/dev/mem", O_RDWR | O_SYNC)

ผลลัพธ์ (ไทย) 1:

ตัวประมวลผล ช่วงที่มันอยู่คือจาก 0x0000000 0xefffffff ในขณะที่ช่วงอยู่ของความทรงจำทั้งในท้องถิ่นจาก 0xf0000000 0xffffffff โดยค่าเริ่มต้น โปรแกรมจะ โหลดในหน่วยความจำร่วม แผนที่แต่ละหน่วยความจำเต็ม ตัวประมวลผลถูกแมปไปยังวัตถุหน่วยความจำร่วมยกเว้น ส่วนเล็ก ๆ ของหน่วยความจำภายในสำหรับแต่ละกอง ดังนั้น การ ใช้ฟังก์ชัน icmLoadProcessorMemory() สำหรับหนึ่งครั้ง ตัวประมวลผล โดยวิธีนี้ โหลดโปรแกรมประยุกต์ในการใช้ร่วมกัน หน่วยความจำที่โปรเซสเซอร์ทั้งสองจะดำเนินการเหมือนกัน รหัสหลักและแต่ละตัวประมวลผลดำเนินงาน งานสามารถ ขึ้นอยู่กับ หรือเป็นอิสระ เป็นหน่วยความจำใช้ร่วมกันเชื่อมต่อที่อยู่ 0 เรา ควรใช้ค่าสถานะสำหรับการซิงโครไนส์ระหว่างที่แตกต่างกัน ตัวประมวลผล ตัวจัดกำหนดการของการ OVPsim เริ่มต้นด้วยการ ตัวประมวลผลที่มีตัวระบุด้านบน ดังนั้น จะได้รับการดำเนินการ สั่งซื้อที่เหมาะกับโปรแกรมของเรา ค่าสถานะเป็นการแก้ปัญหา ถึง แบ่งงานระหว่างตัวประมวลผล เราใช้ impProcessorId() การ โทรซึ่งเป็นฟังก์ชั่น Imperas ที่ใช้ในการระบุตัวประมวลผล ข.หน่วยความจำที่อยู่ของรถบัสเฉพาะ แทนการเชื่อมต่อหน่วยความจำใช้ร่วมกันครั้งแรก ที่อยู่: 0x00000000 มันสามารถเชื่อมต่อที่มีอยู่ที่ เป็นของรถช่วงที่อยู่ที่ถูกแมป หรือใช้ โดยคอมโพเนนต์อื่น ๆ เรากำหนดสถาปัตยกรรมของตัวประมวลผลสอง เชื่อมต่อกับหน่วยความจำที่ใช้ร่วมกันกับช่วงอยู่จาก 0x80000000 0xffffffff แต่ละตัวประมวลผลมีหน่วยความจำท้องถิ่น แมปจาก 0x00000000 กับ 0x7fffffff แอพลิเคชัน โหลดในหน่วยความจำภายในเครื่องมีการเชื่อมต่อที่อยู่ 0x00000000. เราควรมีสองไฟล์แอพลิเคชันที่ s โหลดในหน่วยความจำท้องถิ่นของแต่ละตัวประมวลผล การใช้ร่วมกัน อยู่มีให้มองเห็นสำหรับการประมวลผลทั้งสอง เพื่อเป็นการ ใช้ประโยชน์จากหน่วยความจำใช้ร่วมกันเรียบร้อยแล้ว เราใช้อัลกอริทึม ของปิเตอร์สันสำหรับแยกทั้งสองฝ่าย อัลกอริทึมนี้ช่วยให้สอง กระบวนการในการใช้ทรัพยากรแบบใช้ครั้งเดียว โดยไม่มีข้อขัดแย้งขึ้น หน่วยความจำที่ใช้ร่วมกันสำหรับการสื่อสาร กระบวนการทั้งสองสามารถ ไม่มีในส่วนสำคัญในเวลาเดียวกัน ค.แชร์หน่วยความจำและ Linux การสื่อสารระหว่างตัวประมวลผลที่แตกต่างกัน ระบบปฏิบัติการ (Linux ในกรณีของเรา), เริ่มระบบการใช้การใช้ร่วมกัน หน่วยความจำยังคงอยู่ การแก้ปัญหาที่ถูกต้อง เราใช้หน่วยความจำที่แมป ไฟล์ที่เปิดใช้งานกระบวนการหลายแมปแฟ้มเดียวกัน และ การโต้ตอบระหว่างกัน มีฟังก์ชัน mmap() นี้ บริการ สถาปัตยกรรมมัลติโปรเซสเซอร์ ในกรณีที่ตัวประมวลผล เริ่มระบบ Linux เราควรมีหัวข้อที่: #include การใช้ฟังก์ชัน mmap() ในของเรา โปรแกรมประยุกต์ที่คอมไพล์ข้ามเป้าหมาย การ การแม็ป คือจากพื้นที่อยู่ของกระบวนการวัตถุ แสดง โดยอธิบายแฟ้ม ตามที่แสดงในรูปที่ 1 ตัวระบุแฟ้มนี้ (fd), ควรสามารถสร้างอินสแตนซ์ดังต่อไปนี้: fd =เปิด (" / dev/mem ", O_RDWR | O_SYNC)

ผลลัพธ์ (ไทย) 2:

โปรเซสเซอร์ ช่วงที่อยู่ของมันคือจาก 0x0000000 เพื่อ 0xefffffff
ขณะที่ช่วงที่อยู่ในความทรงจำทั้งในระดับท้องถิ่นจาก
0xf0000000 เพื่อ 0xffffffff โดยค่าเริ่มต้นโปรแกรมจะถูก
โหลดเมื่อหน่วยความจำร่วม แผนที่ของหน่วยความจำเต็มรูปแบบสำหรับแต่ละ
หน่วยประมวลผลถูกแมปลงในวัตถุหน่วยความจำร่วมยกเว้น
ส่วนเล็ก ๆ ของหน่วยความจำภายในสำหรับแต่ละสแต็ค ดังนั้น
icmLoadProcessorMemory ฟังก์ชัน () ถูกนำมาใช้ครั้งเดียวสำหรับหนึ่งใน
การประมวลผล โดยวิธีการนี้โปรแกรมที่มีการโหลดที่ใช้ร่วมกันบน
หน่วยความจำจากโปรเซสเซอร์ซึ่งทั้งสองจะดำเนินการเดียวกัน
รหัสหลักและแต่ละหน่วยประมวลผลดำเนินงานของ งานอาจจะ
ขึ้นอยู่กับหรืออิสระ.
ในฐานะที่เป็นหน่วยความจำที่ใช้ร่วมกันมีการเชื่อมต่อที่อยู่ที่ 0 เรา
ควรใช้ธงสำหรับการประสานระหว่างที่แตกต่างกัน
การประมวลผล นอกจากนี้การจัดตารางเวลาของ OVPsim เริ่มต้นโดย
การประมวลผลที่มีระบุบน ดังนั้นเพื่อให้ได้การดำเนินการ
สั่งซื้อที่เหมาะสมกับโปรแกรมของเรา, ธงที่มีการแก้ปัญหา เพื่อ
แบ่งงานระหว่างตัวประมวลผลเราจะใช้ impProcessorId ()
โทรซึ่งเป็นฟังก์ชั่น Imperas ใช้ในการระบุตัวประมวลผล.
บี หน่วยความจำที่ใช้ร่วมกันที่อยู่รถบัสโดยเฉพาะแทนการเชื่อมต่อหน่วยความจำที่ใช้ร่วมกันในครั้งแรกที่อยู่: 0x00000000 ก็สามารถเชื่อมต่อที่อยู่ใด ๆ ที่เป็นช่วงที่อยู่รถบัสที่ให้ไว้ว่ามันไม่ได้แมป. หรือใช้โดยส่วนประกอบอื่น ๆเรากำหนดสถาปัตยกรรม ประกอบด้วยสองหน่วยประมวลผลที่เชื่อมต่อกับหน่วยความจำที่ใช้ร่วมกันกับช่วงที่อยู่จาก0x80000000 กับโปรเซสเซอร์ 0xffffffff.Each มีหน่วยความจำของท้องถิ่นแมปจาก 0x00000000 เพื่อ 0x7FFFFFFF โปรแกรมประยุกต์ที่ถูกโหลดในหน่วยความจำภายในตามที่มีการเชื่อมต่อที่อยู่ที่0x00000000 เราควรจะมีไฟล์โปรแกรมทั้งสองซึ่งเป็นของโหลดในหน่วยความจำภายในของแต่ละหน่วยประมวลผล ที่ใช้ร่วมกันอยู่ที่จะมองเห็นสำหรับการประมวลผลทั้งสองมี เพื่อที่จะใช้ประโยชน์จากหน่วยความจำที่ใช้ร่วมกันประสบความสำเร็จเราจะใช้อัลกอริทึมของปีเตอร์สันยกเว้นร่วมกัน ขั้นตอนวิธีการนี้จะช่วยให้ทั้งสองกระบวนการในการแบ่งปันทรัพยากรที่ใช้ครั้งเดียวโดยไม่เกิดความขัดแย้งขึ้นอยู่ในหน่วยความจำที่ใช้ร่วมกันสำหรับการสื่อสาร สองกระบวนการสามารถไม่เคยจะอยู่ในส่วนที่สำคัญในเวลาเดียวกัน. ซี หน่วยความจำที่ใช้ร่วมกันและลินุกซ์สำหรับการสื่อสารระหว่างหน่วยประมวลผลที่แตกต่างกันการบูตระบบปฏิบัติการ (Linux ในกรณีของเรา) ที่ใช้ร่วมกันหน่วยความจำยังคงเป็นวิธีการแก้ปัญหาที่ถูกต้อง เราใช้หน่วยความจำที่แมปไฟล์ที่เปิดใช้งานหลายขั้นตอนเพื่อแมไฟล์เดียวกันและปฏิสัมพันธ์ระหว่างพวกเขา mmap () ฟังก์ชันนี้มีบริการ. ในกรณีที่มีสถาปัตยกรรมแบบมัลติโปรเซสเซอร์ที่ประมวลผลบูต Linux เราควรจะรวมถึงส่วนหัว: #include



























เพื่อที่จะใช้ของ mmap () ฟังก์ชันของเราใน
โปรแกรมที่เป็นข้ามเรียบเรียงสำหรับเป้าหมาย ,. การทำแผนที่
จากพื้นที่ที่อยู่ของกระบวนการไปยังวัตถุที่
แสดงโดยอธิบายไฟล์ตามที่ปรากฏในรูปที่ 1
อธิบายไฟล์นี้ (FD) ควรจะยกตัวอย่างดังต่อไปนี้:
FD = open ( "/ dev / Mem" O_RDWR | O_SYNC)

ผลลัพธ์ (ไทย) 3:

โปรเซสเซอร์ ช่วงที่อยู่ 0x0000000 เพื่อ 0xefffffff จากในขณะที่ช่วงที่อยู่ทั้งในความทรงจำจาก0xf0000000 เพื่อ 0xffffffff . โดยค่าเริ่มต้นโปรแกรมจะโหลดในหน่วยความจำที่ใช้ร่วมกัน แผนที่หน่วยความจำเต็มรูปแบบสำหรับแต่ละหน่วยประมวลผลกลางเป็นแมปในหน่วยความจำที่ใช้ร่วมกันวัตถุยกเว้นส่วนเล็ก ๆของหน่วยความจำท้องถิ่นของแต่ละกอง ดังนั้นicmloadprocessormemory() ฟังก์ชันจะใช้สักครั้งหนึ่งของโปรเซสเซอร์ โดยวิธีนี้ มีการโหลดบนแบ่งปันหน่วยความจำที่โปรเซสเซอร์จะประหารเหมือนกันทั้งหลักรหัสและโปรเซสเซอร์แต่ละตัวรันงานของมัน งานที่สามารถหรือตัวแปรอิสระเป็นหน่วยความจำที่ใช้ร่วมกันเชื่อมต่อที่ 0 ที่อยู่เราควรใช้ธงเพื่อประสานระหว่างที่แตกต่างกันโปรเซสเซอร์ นอกจากนี้ การจัดตารางเวลาของ ovpsim เริ่มต้นโดยบนตัวประมวลผลมี . ดังนั้น เพื่อให้การประหารเพื่อให้เหมาะสมกับโปรแกรมของเราธงเป็นวิธีการแก้ปัญหา เพื่อแบ่งงานระหว่างหน่วยประมวลผล เราใช้ impprocessorid()ซึ่งเป็น imperas เรียกฟังก์ชันที่ใช้ระบุหน่วยประมวลผลB . หน่วยความจำที่ใช้ร่วมกันที่เฉพาะรถโดยสารที่อยู่แทนที่จะเชื่อมต่อหน่วยความจำที่ใช้ร่วมกันที่แรกที่อยู่ : 0x00000000 มันสามารถเชื่อมต่อที่อยู่ใด ๆเป็นของที่อยู่ในรถให้มันไม่ตรงกับช่วงหรือใช้ส่วนประกอบอื่น ๆเรากำหนดสถาปัตยกรรมประกอบด้วยสองโปรเซสเซอร์เชื่อมต่อกับหน่วยความจำที่ใช้ร่วมกันกับที่อยู่ช่วงจาก0x80000000 เพื่อ 0xffffffff แต่ละหน่วยประมวลผลหน่วยความจำท้องถิ่นได้แผนที่จาก 0x00000000 เพื่อ 0x7fffffff . โปรแกรมคือโหลดในหน่วยความจำท้องถิ่นเป็นการเชื่อมต่อที่ที่อยู่0x00000000 . เราควรจะมี 2 โปรแกรมแฟ้มที่เโหลดในหน่วยความจำท้องถิ่นของแต่ละหน่วยประมวลผล ที่ใช้ร่วมกันที่อยู่มีให้เห็นทั้งหน่วยประมวลผล เพื่อได้ใช้ประโยชน์จากหน่วยความจำที่ใช้ร่วมกัน เราใช้ขั้นตอนวิธีของปีเตอร์สันสำหรับการยกเว้นร่วมกัน . วิธีนี้จะช่วยให้ทั้งสองกระบวนการที่จะแบ่งปันการใช้ทรัพยากรเดียวโดยไม่มีความขัดแย้งจากในหน่วยความจำที่ใช้ร่วมกันเพื่อการสื่อสาร 2 กระบวนการสามารถไม่เคยอยู่ในส่วนที่สำคัญในเวลาเดียวกันหน่วยความจำที่ใช้ร่วมกันและ Linux .สำหรับการสื่อสารระหว่างโปรเซสเซอร์ที่แตกต่างกันบูต OS ( Linux ในกรณีของเรา ) , การใช้ของร่วมกันหน่วยความจำยังคงเป็นทางออกที่ถูกต้อง เราใช้หน่วยความจำที่แมปไฟล์ซึ่งช่วยให้กระบวนการต่าง ๆในแผนที่ ไฟล์เดียวกันปฏิสัมพันธ์ระหว่างพวกเขา ฟังก์ชัน mmap() ข้อเสนอนี้บริการในกรณีของสถาปัตยกรรมมัลติที่โปรเซสเซอร์บูตลินุกซ์ , เราควรจะรวมถึงส่วนหัว # รวมถึง :< sys / mman H > เพื่อใช้ฟังก์ชัน mmap() ในของเราโปรแกรมที่ข้ามรวบรวมสำหรับเป้าหมาย . แผนที่จากพื้นที่ที่อยู่ของกระบวนการเพื่อวัตถุแสดงโดยหัวเรื่องไฟล์ ดังภาพที่แสดงในรูปที่ 1หัวเรื่องไฟล์นี้ ( FD ) ควร instantiated ดังต่อไปนี้FD = เปิด ( " / dev / แหม่ม " o_rdwr | o_sync )