IV. IMPLEMENTATION AND TEST In orde

IV. IMPLEMENTATION AND TEST
In order to demonstrate our technique using OVPsim, we
conceive and test multiple multiprocessor architectures. As the
hardware development process progresses, software designers
can profit from this advantage to test the behavior of the
software on the hardware. Consequently the hardware and
software development can progress together in lockstep.
To meet the hardware designer's needs, the major producers
of microprocessors with common architectures such as ARM,
MIPS, ARC, SPARC, PowerPC, make Intellectual Property
(IP) cores available for designers in the OVP initiative. An IP
core can be simply integrated in any designed platform. As a
first step, we developed uniprocessor architectures. We have
tested several applications and essentially the 3D synthesis one
which consists in displaying a 3D object. To run the
application, we just have to enter the number of the object we
want to display and then we get the corresponding pixel matrix.
Then, we move to our main objective which is the simulation
of multiprocessor architectures.
A. Homogeneous architectures with shared memory
Homogeneous architecture is composed of several
processing units having the same features and characteristics.
We developed different architectures based on different IP
cores: ARM7, MIPS32, OpenCores (OR1K), etc. We can
define the number of processors that we want in our design.
We should only respect the address range for each component.
As an example of homogeneous architecture, we made an
architecture composed of two OR1K cores connecting to a
shared memory. Its address range is from 0x0000000 to
0xefffffff, while the address range of both local memories is
from 0xf0000000 to 0xffffffff. Both processors execute the
same application as the shared memory starts at the address
0x0000000, as it is detailed in Section III. The application we
run on the shared memory based architecture consists of two

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

IV. การใช้งานและทดสอบ เพื่อแสดงให้เห็นถึงเทคนิคของเราใช้ OVPsim เรา ตั้งครรภ์ และทดสอบสถาปัตยกรรมมัลติโปรเซสเซอร์หลาย เป็นการ ดำเนินกระบวนการพัฒนาฮาร์ดแวร์ นักออกแบบซอฟต์แวร์ สามารถใช้ประโยชน์จากสิ่งนี้จะทดสอบการทำงานของการ ซอฟต์แวร์ฮาร์ดแวร์ ดังนั้นฮาร์ดแวร์ และ พัฒนาซอฟต์แวร์สามารถพัฒนาร่วมกันใน lockstep เพื่อตอบสนองการออกแบบฮาร์ดแวร์ที่ต้องการ ผู้ผลิตรายใหญ่ ของไมโครโปรเซสเซอร์มีสถาปัตยกรรมทั่วไปเช่นแขน MIPS, ARC, SPARC, PowerPC ทำให้ทรัพย์สินทางปัญญา (IP) แกนสำหรับนักออกแบบในพระราชดำริ OVP IP หลักสามารถรวมเพียงในแพลตฟอร์มใด ๆ ออก เป็นการ ขั้นแรก เราพัฒนาสถาปัตยกรรม uniprocessor เรามี ทดสอบโปรแกรมประยุกต์หลายและหลักการสังเคราะห์ 3 มิติหนึ่ง ซึ่งประกอบด้วยในการแสดงวัตถุ 3 มิติ การเรียกใช้การ โปรแกรม เราก็ต้องป้อนหมายเลขของวัตถุเรา ต้องการแสดง และจากนั้น เราได้เมตริกซ์พิกเซลที่สอดคล้องกัน แล้ว เราย้ายไปที่วัตถุประสงค์หลักของเราซึ่งเป็นการจำลอง ของสถาปัตยกรรมมัลติโปรเซสเซอร์ เอสถาปัตยกรรมเหมือนกับหน่วยความจำที่ใช้ร่วมกัน สถาปัตยกรรมเหมือนกันคือประกอบด้วยหลาย ประมวลผลหน่วยที่มีคุณสมบัติและลักษณะเดียวกัน เราพัฒนาสถาปัตยกรรมต่างกันอิง IP แตกต่างกัน แกน: ARM7, MIPS32, OpenCores (OR1K), เป็นต้น เราสามารถ กำหนดหมายเลขของตัวประมวลผลที่เราต้องการในการออกแบบของเรา เราควรเคารพช่วงอยู่สำหรับแต่ละส่วนเท่าตัว ตัวอย่างของสถาปัตยกรรมเหมือนกัน เราทำการ สถาปัตยกรรมประกอบด้วยสองแกน OR1K ที่เชื่อมต่อกับเครื่อง หน่วยความจำที่ใช้ร่วมกัน ช่วงที่อยู่ของมันคือจาก 0x0000000 เพื่อ 0xefffffff ในขณะที่ช่วงอยู่ของความทรงจำทั้งในท้องถิ่น จาก 0xf0000000 การ 0xffffffff ดำเนินการประมวลผลทั้งสองตัว เริ่มต้นแอพลิเคชันเดียวกันเป็นหน่วยความจำใช้ร่วมกันที่อยู่ 0x0000000 มันมีรายละเอียดในส่วนที่ III โปรแกรมที่เรา รันบนสถาปัตยกรรมหน่วยความจำใช้ร่วมกันประกอบด้วยสอง

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

IV การดำเนินงานและการทดสอบ
เพื่อที่จะแสดงให้เห็นถึงเทคนิคของเราโดยใช้ OVPsim เรา
ตั้งครรภ์และการทดสอบสถาปัตยกรรมแบบมัลติโปรเซสเซอร์หลาย ในฐานะที่เป็น
กระบวนการในการพัฒนาฮาร์ดแวร์ดำเนินออกแบบซอฟต์แวร์
ได้กำไรจากความได้เปรียบนี้เพื่อทดสอบพฤติกรรมของ
ซอฟแวร์บนฮาร์ดแวร์ ดังนั้นฮาร์ดแวร์และ
ซอฟแวร์การพัฒนาสามารถดำเนินการร่วมกันใน lockstep.
เพื่อตอบสนองความต้องการของนักออกแบบฮาร์ดแวร์ของผู้ผลิตรายใหญ่
ของไมโครโปรเซสเซอร์ที่มีสถาปัตยกรรมทั่วไปเช่น ARM,
MIPS, ARC, SPARC, PowerPC ให้ทรัพย์สินทางปัญญา
(IP) แกนใช้ได้สำหรับนักออกแบบใน ความคิดริเริ่ม OVP IP ที่
หลักสามารถบูรณาการเพียงในการออกแบบแพลตฟอร์มใด ๆ ในฐานะที่เป็น
ขั้นตอนแรกที่เราพัฒนาสถาปัตยกรรม uniprocessor เราได้
ผ่านการทดสอบการใช้งานหลายและเป็นหลักสังเคราะห์ 3 มิติหนึ่ง
ซึ่งประกอบด้วยในการแสดงวัตถุ 3 มิติ เมื่อต้องการเรียกใช้
โปรแกรมเราก็ต้องใส่หมายเลขของวัตถุที่เรา
ต้องการแสดงแล้วเราได้รับเมทริกซ์พิกเซลที่สอดคล้องกัน.
จากนั้นเราย้ายไปวัตถุประสงค์หลักของเราซึ่งเป็นแบบจำลอง
ของสถาปัตยกรรมแบบมัลติโปรเซสเซอร์.
เอ สถาปัตยกรรมที่เป็นเนื้อเดียวกันกับหน่วยความจำที่ใช้ร่วมกัน
สถาปัตยกรรมที่เป็นเนื้อเดียวกันประกอบด้วยหลาย
. หน่วยประมวลผลที่มีคุณสมบัติเดียวกันและลักษณะที่
เราได้พัฒนาสถาปัตยกรรมที่แตกต่างกันตาม IP ที่แตกต่างกัน
แกน: ARM7, MIPS32, OpenCores (OR1K) ฯลฯ เราสามารถ
กำหนดจำนวนตัวประมวลผลที่เรา ต้องการในการออกแบบของเรา.
เราควรเคารพช่วงที่อยู่ในแต่ละองค์ประกอบ.
เป็นตัวอย่างของสถาปัตยกรรมที่เป็นเนื้อเดียวกันที่เราทำ
สถาปัตยกรรมประกอบด้วยสอง OR1K แกนเชื่อมต่อกับ
หน่วยความจำที่ใช้ร่วมกัน ช่วงที่อยู่ของมันคือจาก 0x0000000 เพื่อ
0xefffffff ขณะที่ช่วงที่อยู่ในความทรงจำทั้งในระดับท้องถิ่นคือ
จาก 0xf0000000 เพื่อ 0xffffffff โปรเซสเซอร์ทั้งรัน
โปรแกรมเดียวกันเป็นหน่วยความจำที่ใช้ร่วมกันเริ่มต้นที่อยู่
0x0000000 มันเป็นรายละเอียดในส่วนที่สาม แอพลิเคชันที่เรา
ทำงานบนสถาปัตยกรรมตามหน่วยความจำร่วมประกอบด้วยสอง

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

4 . การดำเนินงานและการทดสอบเพื่อแสดงให้เห็นถึงเทคนิคที่เราใช้ ovpsim เราการประดิษฐ์และการทดสอบหลาย ๆ สถาปัตยกรรมแบบมัลติ . เป็นดำเนินกระบวนการพัฒนาฮาร์ดแวร์ นักออกแบบซอฟต์แวร์สามารถกำไรจากประโยชน์นี้เพื่อทดสอบพฤติกรรมของซอฟต์แวร์กับฮาร์ดแวร์ จึงเป็นอุปกรณ์การพัฒนาซอฟต์แวร์สามารถก้าวไปด้วยกันใน lockstep .เพื่อตอบสนองความต้องการฮาร์ดแวร์ของผู้ออกแบบ , ผู้ผลิตรายใหญ่พอใจกับสถาปัตยกรรมทั่วไป เช่น แขนมิปส์ , ส่วนโค้ง , สปาร์คเพาเวอร์พีซี ให้ทรัพย์สินทางปัญญา ,( IP ) แกนของนักออกแบบใน ovp ริเริ่ม ไอพีหลักสามารถบูรณาการใด ๆเพียงแค่ออกแบบในแพลตฟอร์ม เป็นขั้นตอนแรก เราได้พัฒนาสถาปัตยกรรม uniprocessor . เรามีทดสอบหลายโปรแกรมและหลัก 3D สังเคราะห์ 1ซึ่งประกอบด้วยในการแสดงวัตถุ 3 มิติ ที่จะเรียกใช้โปรแกรม เราก็ต้องระบุจำนวนของวัตถุที่เราต้องการแสดงแล้วเราได้รับเมทริกซ์พิกเซลที่สอดคล้องกันจากนั้นเราย้ายไปที่วัตถุประสงค์หลักของเรา ซึ่งมีการจำลองของสถาปัตยกรรมแบบมัลติ .สถาปัตยกรรมที่เป็นเนื้อเดียวกันกับหน่วยความจำที่ใช้ร่วมกัน .สถาปัตยกรรมซึ่งประกอบด้วยหลายหน่วยประมวลผลมีคุณลักษณะเดียวกันและลักษณะเราพัฒนาบนพื้นฐานของ IP ที่แตกต่างกันแตกต่างกันสถาปัตยกรรมแกน : อาร์ม 7 mips32 opencores , , ( or1k ) , ฯลฯ เราสามารถกำหนดจำนวนของหน่วยประมวลผลที่เราต้องการในการออกแบบของเราเราควรจะเคารพช่วงที่อยู่สำหรับแต่ละองค์ประกอบเป็นตัวอย่างของสถาปัตยกรรมเป็นเนื้อเดียวกัน ทำให้เราเป็นสถาปัตยกรรมประกอบด้วยสอง or1k แกนเชื่อมต่อหน่วยความจำที่ใช้ร่วมกัน ช่วงที่อยู่ 0x0000000 เพื่อจาก0xefffffff ในขณะที่ช่วงที่อยู่ทั้งในความทรงจำคือจาก 0xf0000000 เพื่อ 0xffffffff . ทั้งสองตัว รันโปรแกรมเดียวกันกับหน่วยความจำที่ใช้ร่วมกันเริ่มต้นที่ที่อยู่0x0000000 ตามที่มีรายละเอียดในส่วนที่ III โปรแกรมเราเรียกใช้ในหน่วยความจำที่ใช้ร่วมกันที่ใช้สถาปัตยกรรมประกอบด้วยสอง