1. จำนวนโปรเซสทั้งหมดจะต้องมีจำนวนเท่ากับ (N/K)^2 + 1
2. ค่าของความกว้างของบอร์ด(N) และขนาดของTile(K) จะต้องมีค่าอย่างน้อย 1 และ ค่าของ N จะต้องหารด้วย k ลงตัวเสมอ
3. ค่าการสุ่มความน่าจะเป็นในการมีชีวิตของแต่ละเซลจะต้องมีค่าอยู่ระหว่าง [0, 100] เท่านั้น

การคอมไพล์โปรแกรมและการใช้งาน

1. คอมไพล์โปรแกรมด้วยคำสั่ง mpicc -o Game_of_Life Game_of_Life.c จะได้ไฟล์โปรแกรมชื่อ Game_of_Life
2. รันโปรแกรมด้วยคำสั่ง mpirun –np processnum Game_of_Life โดยจะต้องกำหนดจำนวนโปรเซสให้ถูกต้องตามข้อกำหนด
3. โปรแกรมจะถามถึงค่าของ ความกว้างของบอร์ด(N) ขนาดของTile(K) จำนวนหน่วยเวลา(t) ต้องการอ่านค่าเริ่มต้นจากไฟล์หรือสุ่มจากโปรแกรม ถ้าเลือกอ่านค่าจากไฟล์จะต้องกำหนดชื่อไฟล์ด้วย หากเลือกสุ่มจากโปรแกรมจะต้องกำหนดค่าความน่าจะเป็นในการที่แต่ละช่องจะมีชีวิตด้วย และ ต้องการเซฟไฟล์ Immediate หรือไม่  ซึ่งจะต้องกรอกให้สอดคล้องกับจำนวนโปรเซสที่กำหนดไว้ หากข้อมูลที่กรอกไม่สอดคล้องหรือไม่ถูกต้องได้แก่

• ค่า N หรือ k ไม่ใช่เลขจำนวนเต็มบวก
• N หาร k ได้ไม่ลงตัว
• จำนวนโปรเซสไม่ถูกต้อง
• ไม่พบไฟล์ที่ต้องการอ่าน

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

การออกแบบโปรแกรมและขั้นตอนการทำงาน

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

1. โปรเซส 0 จะจองพื้นที่บอร์ดขนาด N x N เพื่อรับข้อมูลจากไฟล์หรือสุ่มขึ้น ส่วนโปรเซสอื่นทั้งหมดจะทำการจองบอร์ดย่อยขนาด (K + 2) x (K + 2) ซึ่งจะสร้างขอบเพิ่มให้กับแต่ละ Tile ในทุกด้านเพื่อใช้ในการคำนวน โดยบอร์ดย่อยที่สร้างขึ้นจะสร้างขึ้นเป็นจำนวน 2 บอร์ดเพื่อใช้ในการคำนวน จากนั้นส่งค่าของ N, k, t ไปยังทุกโปรเซสด้วยคำสั่ง MPI_Bcast()

2. จากนั้นโปรเซส 0 จะแบ่งบอร์ดเป็น Tile และส่งไปให้แต่ละโปรเซสเรียงตามลำดับจากซ้ายไปทางขวาและขึ้นแถวใหม่จนครบดังภาพที่ 1

ภาพที่ 1

3. โปรเซสอื่นทั้งหมดจะรับมาเก็บไว้ที่ตรงกลางของบอร์ดย่อยที่มีความยาวมากกว่าขนาดของ Tile อยู่ 2 ดังภาพที่ 2

ภาพที่ 2

4. ส่งข้อมูลระหว่างแต่ละโปรเซสเพื่อคำนวนเวลาถัดไปของแต่ละ Tile ด้วยการตรวจสอบว่าแต่ละโปรเซสจะต้องส่งค่าไปยังโปรเซสใดบ้าง และรับค่ามาจากโปรเซสที่ส่งค่าไปหาเสมอ

• โปรเซสที่มี Tile ที่ไม่ได้อยู่ขอบบนและไม่ได้อยู่ขอบซ้าย ให้ส่งและรับข้อมูลจากโปรเซสที่มี Tile อยู่ด้านซ้ายบน ดังลูกศรสีแดงในภาพที่ 3 โดยคำนวนจากโปรเซสที่ตรงกับเงื่อนไข (rank-1)%c != 0 && (rank-1)/c > 0 โดยจะส่งเฉพาะข้อมูลที่อยู่ในแถวที่สองและหลักที่สองจำนวน 1 ค่าเท่านั้น ดังภาพที่ 4
• โปรเซสที่มี Tile ที่ไม่ได้อยู่ขอบล่างและไม่ได้อยู่ขอบขวา ให้ส่งและรับข้อมูลจากโปรเซสที่มี Tile อยู่ด้านขวาล่าง ดังลูกศรสีเหลืองในภาพที่ 3 โดยคำนวนจากโปรเซสที่ตรงกับเงื่อนไข rank%c != 0 && (rank-1)/c < c-1 โดยจะส่งเฉพาะข้อมูลที่อยู่ในแถวรองสุดท้ายและหลักรองสุดท้ายจำนวน 1 ค่าเท่านั้น ดังภาพที่ 4
• โปรเซสที่มี Tile ที่ไม่ได้อยู่ขอบบน ให้ส่งและรับข้อมูลจากโปรเซสที่มี Tile อยู่ด้านบน ดังลูกศรสีส้มในภาพที่ 3 โดยคำนวนจากโปรเซสที่ตรงกับเงื่อนไข (rank-1)/c > 0 โดยจะส่งเฉพาะข้อมูลในแถวที่สอง ตั้งแต่หลักที่สองจนถึงหลักรองสุดท้ายรวมทั้งสิ้น k ค่า ดังภาพที่ 5
• โปรเซสที่มี Tile ที่ไม่ได้อยู่ขอบล่าง ให้ส่งและรับข้อมูลจากโปรเซสที่มี Tile อยู่ด้านล่าง ดังลูกศรสีม่วงในภาพที่ 3 โดยคำนวนจากโปรเซสที่ตรงกับเงื่อนไข (rank-1)/c < c-1 โดยจะส่งเฉพาะข้อมูลในแถวรองสุดท้าย ตั้งแต่หลักที่สองจนถึงหลักรองสุดท้ายรวมทั้งสิ้น k ค่า ดังภาพที่ 5
• โปรเซสที่มี Tile ที่ไม่ได้อยู่ขอบบนและไม่ได้อยู่ขอบขวา ให้ส่งและรับข้อมูลจากโปรเซสที่มี Tile อยู่ด้านขวาบน ดังลูกศรสีเขียวในภาพที่ 3 โดยคำนวนจากโปรเซสที่ตรงกับเงื่อนไข (rank-1)/c > 0 && rank%c !=0 โดยจะส่งเฉพาะข้อมูลที่อยู่ในแถวที่สองและหลักรองสุดท้ายจำนวน 1 ค่าเท่านั้น ดังภาพที่ 6
• โปรเซสที่มี Tile ที่ไม่ได้อยู่ขอบล่างและไม่ได้อยู่ขอบซ้าย ให้ส่งและรับข้อมูลจากโปรเซสที่มี Tile อยู่ด้านซ้ายล่าง ดังลูกศรสีน้ำเงินในภาพที่ 3 โดยคำนวนจากโปรเซสที่ตรงกับเงื่อนไข (rank-1)/c < c-1 && (rank-1)%c != 0 โดยจะส่งเฉพาะข้อมูลที่อยู่ในแถวรองสุดท้ายและหลักที่สองจำนวน 1 ค่าเท่านั้น ดังภาพที่ 6
• โปรเซสที่มี Tile ที่ไม่ได้อยู่ขอบขวา ให้ส่งและรับข้อมูลจากโปรเซสที่มี Tile อยู่ด้านขวา ดังลูกศรสีฟ้าในภาพที่ 3 โดยคำนวนจากโปรเซสที่ตรงกับเงื่อนไข rank%c !=0 โดยจะส่งเฉพาะข้อมูลในหลักรองสุดท้าย ตั้งแต่แถวที่สองจนถึงแถวรองสุดท้ายรวมทั้งสิ้น k ค่า ดังภาพที่ 7
• โปรเซสที่มี Tile ที่ไม่ได้อยู่ขอบซ้าย ให้ส่งและรับข้อมูลจากโปรเซสที่มี Tile อยู่ด้านซ้าย ดังลูกศรสีดำในภาพที่ 3 โดยคำนวนจากโปรเซสที่ตรงกับเงื่อนไข (rank-1)%c != 0 โดยจะส่งเฉพาะข้อมูลในหลักที่สอง ตั้งแต่แถวที่สองจนถึงแถวรองสุดท้ายรวมทั้งสิ้น k ค่า ดังภาพที่ 7

หมายเหตุ: rank เป็นหมายเลขของโปรเซส, c เป็นจำนวนเต็มบวกที่ได้มาจาก N/k

ภาพที่ 3

ภาพที่ 4	ภาพที่ 5
ภาพที่ 6	ภาพที่ 7

MPI Defined Type ที่ใช้

MPI_Subboard_type : บอร์ดย่อยที่ได้จากการแบ่งเป็น Tile ของบอร์ดใหญ่เพื่อส่งจากโปรเซส 0 ไปยังโปรเซสอื่น
MPI_Type_vector(K, K, N, MPI_INT, &MPI_Subboard_type);

MPI_Subboard_type2 : บอร์ดย่อยที่ใช้ในการประมวลผลของแต่ละโปรเซส และรับส่งบอร์ดย่อยกับโปรเซส 0
MPI_Type_vector(K, K, K+2, MPI_INT, &MPI_Subboard_type2);

MPI_Boardrow_type : แถวของบอร์ดย่อยที่ใช้ในการส่งระหว่าง Tile ที่อยู่ด้านล่างและบน
MPI_Type_contiguous(K, MPI_INT, &MPI_Boardrow_type);

MPI_Boardcol_type : หลักของบอร์ดย่อยที่ใช้ในการส่งข้อมูลระหว่าง Tile ที่อยู่ด้านซ้ายและขวา
MPI_Type_vector(K, 1, K+2, MPI_INT, &MPI_Boardcol_type);

ตัวอย่างการใช้งานแบบอ่านค่าจากไฟล์

$ mpirun –np 5 Game_of_Life
Enter board size (N): 6
Enter tile size (K): 3
Enter time step (t): 2
Do you want to save immediate file (yes/no): yes
Read board from file (yes/no – if no board is initialize by random): yes
Enter input file name : inputboard2.txt

ตัวอย่างการใช้งานแบบสุ่มความน่าจะเป็นของการมีชีวิต

$ mpirun –np 5 Game_of_Life
Enter board size (N): 6
Enter tile size (K): 3
Enter time step (t): 8
Do you want to save immediate file (yes/no): no
Read board from file (yes/no – if no board is initialize by random): no
Random life cell probability (0-100): 60

ดาวน์โหลด : ซอร์สโค้ด, ตัวอย่าง input 1, ตัวอย่าง input 2

1. เริ่มต้นด้วยการเปิดเครื่องปลายทางด้วยคำสั่ง kvm -m 512 host.img -incoming tcp:0.0.0.0:8000 โดย

• -m 512 หมายถึงให้เปิดเครื่องโดยกำหนด memory ไว้ที่ 512 MB (ใส่หรือไม่ใส่ก็ได้)
• host.img อิมเมจไฟล์ของเครื่องที่จะทำการย้าย
• -incoming tcp:0.0.0.0:8000 เป็นการบอกว่าจะทำการ migrate ผ่านทาง tcp ที่ ip 0.0.0.0 และ port 8000

เมื่อเปิดเครื่องสำเร็จ ตัวเครื่องจะอยู่ในสถานะ stopped รอการย้ายการทำงานมาที่เครื่อง

2. เปิดเครื่องที่จะทำการ Migrate โดยใช้คำสั่ง kvm -m 512 host.img เหมือนทำการเปิด virtual machine ปรกติ

3. ทดสอบการทำงานของการ Migrate ด้วยการเปิดโปรแกรม Siag บนหน้าจอ Desktop

4. เข้าสู่ command mode ของ kvm ด้วยการกด ctrl+alt+2

5. พิมพ์คำสั่ง migrate -d tcp:0.0.0.0:8000 ลงไปเพื่อเป็นการบอกว่าให้ทำการ migrate ไปที่ ip 0.0.0.0 และ port 8000

6. จากนั้นที่เครื่องปลายทางจะสังเกตุเห็นว่าการทำงานของเครื่องต้นทางถูกย้ายมาทำงานที่เครื่องปลายทาง สังเกตุได้จากโปรแกรม Siag ที่ได้เปิดเอาไว้ก่อนทำการ migrate

1. ก่อนอื่นทำการดาวน์โหลด HPC Pack 2008 SDK จากลิงค์ http://www.microsoft.com/downloads/details.aspx?FamilyID=12887DA1-9410-4A59-B903-693116BFD30E&displaylang=en และติดตั้งโปรแกรม

2. เปิดโปรแกรม Microsoft Visual Studio 2008 สร้างโปรเจคใหม่ โดยเลือกที่ Visual C++ >> Win32 และเลือกรูปแบบโปรเจคเป็น Win32 Console Application ใส่ชื่อของโปรเจคที่ต้องการที่ช่อง Name ด้านล่าง

3. เมื่อเลือกที่ Win32 Console Application แล้วกด OK จะปรากฏหน้าต่างใหม่ขี้น ให้กดปุ่ม Next > และเลือกเช็ค Precompiled header ออก แล้วจึงกด Finish

4. หลังจากสร้างโปรเจคเสร็จแล้ว ให้คลิกขวาที่โปรเจคและเลือกที่ Properties  เลือกเมนูในส่วนของ Configuration Properties >> C/C++ >> General และเพิ่มพาธของที่อยู่เฮดเดอร์ไฟล์ โดยปกติแล้วจะอยู่ที่ C:\Program Files\Microsoft HPC Pack 2008 SDK\Include ในช่อง Additional Include Directories

5. เลือกเมนู Configuration Properties >> Linker >> General และใส่พาธของที่อยู่ไลบรารี ซึ่งปกติจะอยู่ที่ C:\Program Files\Microsoft HPC Pack 2008 SDK\Lib\i386 ในช่อง Additional Library Directories

6. เลือกเมนู Configuration Properties >> Linker >> Input  และพิมพ์ msmpi.lib ในช่อง Additional Dependencies

7. เลือกเมนู Configuration Properties >> Linker > System และในช่อง SubSystem ให้เลือกเป็น Console(/SUBSYSTEM:CONSOLE)

8. ทดสอบโปรแกรมโดยพิมพ์โค้ดดังต่อไปนี้

#include <stdio.h>
#include <mpi.h> 

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);

	if(rank==0){
		printf("Hello Kitty form root\n");
	}
	else{
		printf("Hello Kitty from rank %d\n", rank);
	}

	MPI_Finalize();

	return 0;
}

9. Build โปรแกรมด้วย Build >> Build Solution แล้วรันโปรแกรมด้วยการออกคำสั่ง mpiexec -n 10 programname.exe (อยู่ในโฟลเดอร์ Debug หลังจาก build เสร็จ) จะได้ผลลัพท์ดังนี้

ข้อควรระวัง : ทุกครั้งที่ใช้ฟังก์ชัน printf() ต้องเพิ่มคำสั่ง fflush (stdout); ตามไปด้วยเสมอ (เป็นบัคที่มาจากการ Implement MPI ของ Microsoft)

แหล่งข้อมูลเพิ่มเติม

http://blogs.msdn.com/risman/archive/2009/01/04/ms-mpi-with-visual-studio-2008.aspx

http://www.cs.utah.edu/~delisi/vsmpi/

http://www.oerc.ox.ac.uk/resources/wcc/support/documentation/sub-documentation/mpi

1. เมื่อเริ่มต้นติดต่อไปยังเครื่อง hpccluster.cs.tu.ac.th เป็นครั้งแรก ระบบจะถามถึง passphrase ที่ต้องการใช้ และตำแหน่งที่เก็บ passphrase เพื่อใช้ในการเข้ารหัส private key

2. ใช้คำสั่ง $ ssh-agent /bin/sh เพื่อให้สามารถสั่งงาน compute-node โดยที่ไม่จำเป็นจะต้องกรอก passphrase เข้าไปใหม่ และใช้คำสั่ง $ ssh-add เพื่อให้ private-key ถูกโหลดขึ้นไปยังหน่วยความจำ เมื่อเรียกโปรแกรมนี้ โปรแกรมจะถามถึง passphrase เพื่อใช้ในการถอดรหัส ให้กรอก passphrase ตามที่ได้ตั้งไว้

3. ใช้คำสั่ง $ cluster-fork uptime เพื่อแสดงว่าเครื่อง compute-node ใดบ้างที่ทำงานอยู่และมี workload เป็นอย่างไร ซึ่งเมื่อทำการ Redirect ออกมาเป็นไฟล์ด้วยคำสั่ง $ cluster-frok uptime > output และทำการโหลดไฟล์มายังเครื่องด้วยโปรแกรมจะได้ไฟล์ที่มีข้อมูลดังนี้

compute-0-14: down
compute-0-17:  21:04:52 up 30 days, 12:14,  0 users,  load average: 0.00, 0.00, 0.00

compute-0-20:  21:04:52 up 30 days, 12:15,  0 users,  load average: 0.00, 0.00, 0.00

compute-0-28: down
compute-0-29:  21:04:55 up 30 days, 12:14,  0 users,  load average: 0.00, 0.00, 0.00

compute-0-30:  21:04:55 up 30 days, 12:15,  0 users,  load average: 0.15, 0.08, 0.01

compute-0-31:  21:04:56 up 30 days, 12:15,  0 users,  load average: 0.00, 0.00, 0.00

compute-0-32: down

MPI Programming

1. คัดลอกโฟลเดอร์ของไฟล์โปรแกรม MPI ตัวอย่างโดยใช้คำสั่ง $ cp -r /opt/mpich/gnu/examples /home/cs4270904/examples ทำการคอมไพล์โปรแกรม cpi.c ด้วยคำสั่ง $ mpicc cpi.c –o cpi โดยจะได้ executable file ชื่อว่า cpi

2. ออกคำสั่ง $ lamboot เพื่อสร้าง LAM runtime system และออกคำสั่ง $ lamnodes เพื่อตรวจสอบว่ามีเครื่องใดอยู่ใน LAM runtime system ซึ่งควรจะมีเพียงเครื่องเดียว เนื่องจากยังไม่ได้กำหนดเครื่องอื่นเพิ่มเติม

3. รันโปรแกรม cpi ด้วยคำสั่ง $ mpirun –np 1 cpi โดยที่ –np1 หมายถึงให้รันโปรแกรมโดยใช้ 1 โพรเซส จะได้ผลลัพท์คือ

ทดสอบด้วยการเพิ่มจำนวนโพรเซสที่ใช้รันเป็น 4 และ 8 ตามลำดับ

โปรแกรม cpi ทำหน้าที่หาค่า Pi ซึ่งจากการทดสอบพบว่ายิ่งเพิ่มจำนวนโพรเซสก็จะใช้เวลาในการทำงานเพิ่มขึ้น เนื่องจากยังกำหนดให้ประมวลผลบนเครื่องเดียว และยิ่งเพิ่มจำนวนโพรเซสก็จะยิ่งได้ค่า Pi ที่แม่นยำขึ้น (Error ลดน้อยลง)

4. และเมื่อทดสอบการใช้งานแล้วให้ออกคำสั่ง $ lamhalt เพื่อปิด LAM runtime system

5. เพื่อที่จะรันโปรแกรมด้วยการใช้เครื่องหลายเครื่องช่วยกันประมวลผล จะต้องทำการสร้าง hostfile ที่จะระบุชื่อของเครื่องทั้งหมดที่จะใช้งาน (ดูเครื่องที่ปัจจุบันสามารถใช้งานได้จากคำสั่ง cluster-fork uptime) ซึ่งในที่นี้จะตั้งชื่อไฟล์ว่า machine จะเปิดระบบ LAM runtime system ใหม่โดยใช้คำสั่ง $ lamboot machines เพื่อให้เริ่มต้นการทำงานโดยมีเครื่องภายในไฟล์ machines เป็นเครื่อง cluster ที่จะร่วมกันทำงาน ไฟล์ machine ที่ใช้ เป็นดังนี้

hpccluster
compute-0-17
compute-0-20
compute-0-29
compute-0-30
compute-0-31

6. จากนั้นใช้คำสั่ง $ lamnodes เพื่อดูเครื่องทั้งหมดที่ทำงานอยู่

7. ทดสอบการรันโปรแกรม cpi อีกครั้ง ซึ่งแตกต่างจากเดิมในส่วนที่ครั้งนี้จะใช้เครื่องหลายเครื่องช่วยในการประมวลผลโดยออกคำสั่งคือ $ mpirun n1-5 –np 4 cpi ซึ่งหมายถึงให้ใช้เครื่อง n1 ถึง n5 ในการประมวลผล (ไม่ใช้เครื่อง hpscluster เป็น front node) และใช้โพรเซสจำนวนทั้งหมด 4 โพรเซส ได้ผลลัพท์คือ

และทดลองใช้ 8 โพรเซส

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

8. คัดลอกโปรแกรม Master/slave จากเว็บ http://www.mcs.anl.gov/research/projects/mpi/tutorial/mpiexmpl/src2/io/C/main.html และเซฟไฟล์ด้วยชื่อ io.c จากนั้นทำการอัพโหลดขึ้นไปยังเครื่อง Server โดยโปรแกรมนี้มีการทำงานคือจะส่งข้อความจากโพรเซสที่เป็น Slave มายังโพรเซสที่เป็น Master และทำการแสดงผลออกทางหน้าจอ

9. คอมไพล์โปรแกรมด้วยคำสั่ง $ mpicc io.c –o io และทดสอบรันด้วยการใช้ 4 โพรเซส ซึ่งจะมีโพรเซสที่เป็น Master 1 โพรเซส และ Slave อีก 3 โพรเซส

#include <stdio.h>
#include <time.h>
#define MAX_WIDTH 1000

FILE *f;
char board1[MAX_WIDTH * MAX_WIDTH];
char board2[MAX_WIDTH * MAX_WIDTH];
char *currentBoard;
char *pastBoard;
int maxx, maxy;

void init();                           	        /* initial board */
void rand_init_pop(int rand_size);      	/* initial population */
int in_bound(int i, int j);
int neighbor_num(int i, int j);
void process();
void print_board();
void write_to_file();

int main(){
     int i, t = 10;
     int randnum = 0;

     printf("Enter board width : ");
     scanf("%d", &maxx);
     printf("Enter board height : ");
     scanf("%d", &maxy);
     printf("Enter number of random population : ");
     scanf("%d", &randnum);
     printf("Enter time step : ");
     scanf("%d", &t);

     pastBoard = board1;
     currentBoard = board2;

     init();
     rand_init_pop(randnum);

     f = fopen("sequential_board.txt", "w");

     for(i=0;i<t;i++){
          fprintf(f, "t = %d\n", i);
          write_to_file();
          process();
     }
     fprintf(f, "t = %d\n", i);
     write_to_file();

     fclose(f);

     return 0;
}
void init(){
     int i, j;
     for(i=0;i<maxy;i++) for(j=0;j<maxx;j++)
          board1[i * maxx + j] = board2[i * maxx + j] = 'O';
}
void rand_init_pop(int rand_size){
     int i, x, y;
     srand( time(0));

     for(i=0;i<rand_size;i++){
          y = rand() % maxy;
          x = rand() % maxx;
          if(pastBoard[y * maxx + x] == 'X') i--;
          else pastBoard[y * maxx + x] = 'X';
     }
}
int in_bound(int i, int j){
     if(i<0 || j=maxy || j>=maxy)    return 0;
     else                                    return 1;
}
int neighbor_num(int i, int j){
     int num = 0;
     if( in_bound(i-1,j-1) && pastBoard[(i-1) * maxx + (j-1)]=='X' ) num++;
     if( in_bound(i-1, j ) && pastBoard[(i-1) * maxx + ( j )]=='X' ) num++;
     if( in_bound( i ,j-1) && pastBoard[( i ) * maxx + (j-1)]=='X' ) num++;
     if( in_bound(i+1,j+1) && pastBoard[(i+1) * maxx + (j+1)]=='X' ) num++;
     if( in_bound(i+1, j ) && pastBoard[(i+1) * maxx + ( j )]=='X' ) num++;
     if( in_bound( i ,j+1) && pastBoard[( i ) * maxx + (j+1)]=='X' ) num++;
     if( in_bound(i+1,j-1) && pastBoard[(i+1) * maxx + (j-1)]=='X' ) num++;
     if( in_bound(i-1,j+1) && pastBoard[(i-1) * maxx + (j+1)]=='X' ) num++;
     return num;
}
void process(){
     int i,j;
     char* tmp;

     for(i=0;i<maxy;i++){
          for(j=0;j<maxx;j++){
               //For a space that is 'populated'
               if(pastBoard[i * maxx + j]=='X'){
                    //Each cell with one or no neighbors dies, as if by loneliness.
                    if(neighbor_num(i,j) <= 1) currentBoard[i * maxx + j] = 'O';
                    //Each cell with two or three neighbors survives.
                    else if(neighbor_num(i,j) <= 3) currentBoard[i * maxx + j] = 'X';
                    // Each cell with four or more neighbors dies, as if by overpopulation.
                    else currentBoard[i * maxx + j] = 'O';
               }
               //For a space that is 'empty' or 'unpopulated'
               else{
                    // Each cell with three neighbors becomes populated.
                    if(neighbor_num(i,j) == 3) currentBoard[i * maxx + j] = 'X';
                    else currentBoard[i * maxx + j] = 'O';
               }
          }
     }
     tmp = pastBoard;
     pastBoard = currentBoard;
     currentBoard = tmp;
}
void write_to_file(){
     int i, j;
     for(i=0;i<maxy;i++){
          for(j=0;j<maxx;j++){
               if(pastBoard[i * maxx + j]=='X')    fprintf(f, "1”);
               else                                fprintf(f, "0”);
          }
          fprintf(f, "\n");
     }
     fprintf(f, "\n");
}

เมื่อเริ่มต้นโปรแกรม โปรแกรมจะให้ใส่ข้อมูลขนาดความกว้าง และความสูงของตารางที่จะใช้ จากนั้นจะถามถึงจำนวน Cell ที่มีชีวิตเริ่มต้นที่ต้องการกำหนด โดยจะมีตำแหน่งแบบสุ่ม และสุดท้ายจะถามถึง จำนวนหน่วยเวลาที่ต้องการทำการ Simulation เมื่อใส่ข้อมูลครบแล้วโปรแกรมจะทำงาน และเขียนข้อมูลของตารางในแต่ละช่วงเวลาไปยังไฟล์ที่ชื่อ “sequential_board.txt”

2. การทำงานของโปรแกรม Game of Life บนจีพียู ใน 1 time step จะต้องเข้าถึงหน่วยความจำเฉลี่ยประมาณ 8 ครั้งต่อ 1 เทรด ดังนั้นเพื่อให้มีความรวดเร็วในการทำงาน จะต้องทำการคัดลอดข้อมูลจาก Global Memory มายัง Shared Memory ก่อน เพื่อให้เข้าถึงหน่วยความจำได้เร็วขึ้น โดยวิธีที่ใช้คือการแบ่งการทำงานออกเป็นเทรดบล็อคโดยที่ในตอนเริ่มต้นการทำงาน แต่ละเทรดบล็อคจะต้องคัดลอกข้อมูลในส่วนของ cell ที่มีพื้นที่ติดกันกับพื้นที่ที่เทรดบล็อคนั้นรับผิดชอบมาด้วย แต่ในการเขียนข้อมูลจะเขียนข้อมูลลงใน Global Memory ในช่องที่เทรดบล็อคนั้นรับผิดชอบเท่านั้น

#include <stdio.h>
#include <math.h>
#include <time.h>
#define MAX_WIDTH 500
#define TILE_WIDTH 16
#define TY threadIdx.y
#define TX threadIdx.x

void rand_init_pop(int *board, int maxx, int maxy, int rand_size);
void write_to_file(FILE *f, int *board, int maxx, int maxy);

__global__ void process(int *board, int maxx, int maxy);

int main(){
     int *board, *d_board, i, t;
     int maxx, maxy, size, randnum;
     FILE *f;

     printf("Enter board width : ");
     scanf("%d", &maxx);
     printf("Enter board height : ");
     scanf("%d", &maxy);
     printf("Enter number of random population : ");
     scanf("%d", &randnum);
     printf("Enter time step : ");
     scanf("%d", &t);
     size = sizeof(int) * maxx * maxy;

     f = fopen("cuda_board.txt", "w");

     board = (int*)malloc(size);
     cudaMalloc((void**)&d_board, size);
     rand_init_pop(board, maxx, maxy, randnum);

     dim3 blockDim(TILE_WIDTH+2, TILE_WIDTH+2);
     dim3 gridDim(ceil(maxy*1.0/TILE_WIDTH), ceil(maxx*1.0/TILE_WIDTH));

     cudaMemcpy(d_board, board, size, cudaMemcpyHostToDevice);

     for(i=0;i<t;i++){
          fprintf(f, "t = %d\n", i);
          write_to_file(f, board, maxx, maxy);

          process<<>>(d_board, maxx, maxy);
          cudaMemcpy(board, d_board, size, cudaMemcpyDeviceToHost);
     }
     fprintf(f, "t = %d\n", i);
     write_to_file(f, board, maxx, maxy);

     fclose(f);
     free(board);
     cudaFree(d_board);

     return 0;
}

void init(int *board, int maxx, int maxy){
     int i, j;
     for(i=0;i<maxy;i++) for(j=0;j<maxx;j++)
          board[i * maxx + j] = 0;
}
void rand_init_pop(int *board, int maxx, int maxy, int rand_size){
     int i, x, y;
     srand( time(0));
     init(board, maxx, maxy);

     for(i=0;i<rand_size;i++){
          y = rand() % maxy;
          x = rand() % maxx;
          if(board[y * maxx + x] == 1) i--;
          else board[y * maxx + x] = 1;
     }
}
void write_to_file(FILE *f, int *board, int maxx, int maxy){
     for(int i=0;i<maxy;i++){
          for(int j=0;j<maxx;j++)
               fprintf(f, "%d", board[i * maxx + j]);
          fprintf(f, "\n");
     }
     fprintf(f, "\n");
}

__global__ void process(int *board, int maxx, int maxy){
     __shared__ int sboard[TILE_WIDTH+2][TILE_WIDTH+2];

     int i = (blockIdx.x * TILE_WIDTH) + TX - 1;
     int j = (blockIdx.y * TILE_WIDTH) + TY - 1;

     if(i<=maxy && j=0 && j>=0 && i<maxy && j0 && TX0 && TY<TILE_WIDTH){
          int n = 0;
          n += sboard[TY+1][TX+1];
          n += sboard[TY+1][TX-1];
          n += sboard[TY-1][TX-1];
          n += sboard[TY-1][TX+1];
          n += sboard[TY+1][ TX ];
          n += sboard[ TY ][TX+1];
          n += sboard[ TY ][TX-1];
          n += sboard[TY-1][ TX ];

          if(sboard[TY][TX]==1 && n!=2 && n!=3)
               board[boardidx] = 0;
          else if(sboard[TY][TX]==0 && n==3)
               board[boardidx] = 1;
          }
     }
}

เมื่อรันโปรแกรม โปรแกรมจะถามข้อมูลเช่นเดียวกับโปรแกรม Sequential แต่ข้อมูลจะเขียนลงไปที่ไฟล์ที่มีชื่อว่า “cuda_board.txt”

สามารถดาวน์โหลดไฟล์โปรแกรมได้ที่ด้านล่าง
GameOfLife.c
GameOfLifeCUDA.cu

จากโปรแกรมตัวอย่างเมื่อเขียนความสัมพันธ์ในรูปแบบกราฟจะได้กราฟลักษณะข้างต้น ซึ่งหมายความว่าลูปที่ 2 และ 3 ที่เป็นส่วนที่คำนวนค่าของ c และ d สามารถทำงานพร้อมกันได้ ดังนั้นจึงสามารถใช้คำสั่ง #pragma omp sections ในส่วนนี้ และภายในลูปแต่ละลูปก็มีไม่ความสัมพันธ์กันระหว่างแต่ละการวนรอบสังเกตุได้จากการอ้างอิงถึง index เดียวกันในแต่ละการวนรอบเท่านั้น ดังนั้นทุกลูปสามารถใช้คำสั่ง #pragma omp for เพื่อให้เกิดการทำงานแบบขนานขึ้นในแต่ละลูป

โดยสามารถเขียนเป็นโปรแกรมได้ดังดังนี้

#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#define N 50

int main (int argc, char *argv[])
{
     int i, nthreads, tid;
     float a[N], b[N], c[N], d[N];
     float pa[N], pb[N], pc[N], pd[N];

     /* Sequential Program */
     for (i=0; i<N; i++) {
          a[i] = i * 1.5;
          b[i] = i + 22.35;
          c[i] = d[i] = 0.0;
     }

     for (i=0; i<N; i++){
          c[i] = a[i] + b[i];
     }
     for (i=0; i<N; i++){
          d[i] = a[i] * b[i];
     }

     /* Parallel Program with OpenMP */
     #pragma omp parallel for
     for (i=0; i<N; i++) {
          pa[i] = i * 1.5;
          pb[i] = i + 22.35;
          pc[i] = pd[i] = 0.0;
     }

     #pragma omp parallel sections
     {
          #pragma omp section
          #pragma omp parallel for
          for (i=0; i<N; i++){
               pc[i] = pa[i] + pb[i];
          }

          #pragma omp section
          #pragma omp parallel for
          for (i=0; i<N; i++){
               pd[i] = pa[i] * pb[i];
          }
     }

     /* check answers */
     for(i=0;i<N;i++){
          if(c[i]!=pc[i] || d[i]!=pd[i]){
               printf("Compute Error\n");
               break;
          }
     }
     if(i==N) printf("Corrected Answer\n");

     return 0;
}

โปรแกรมดังกล่าวจะทำงานทั้งหมดสองครั้งคือ คำนวนเชิงลำดับ (Sequential) และคำนวนแบบขนาน (Parallel) ด้วยการใช้ OpenMP หลังจากนั้นจะนำคำตอบมาตรวจสอบว่าการคำนวนแบบขนานให้ผลลัพท์เช่นเดียวกับการทำงานเชิงลำดับหรือไม่ ซึ่งหากคำนวนได้ถูกต้องจะปรากฎผลลัพท์ขึ้นมาเป็น Corrected Answer และจะปรากฎผลลัพท์ว่า Compute Error หากทำงานผิดพลาด ในที่นี้จะทำการคอมไพล์ด้วยโปรแกรม gcc เวอร์ชัน 4 ด้วยคำสั่ง

$gcc-4 –fopenmp program1.c –o program1

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

#include <stdio.h>
#include <time.h>
#define DELTA 0.001

int floatIsEqual(float a, float b){
     if( (b<a+DELTA) && (b>a-DELTA) ) return 1;
     else  return 0;
}

__global__ void GPUfunction(float *A, float *B, float *C){
     int i = blockIdx.x * blockDim.x + threadIdx.x;

     if(i<1024)       C[i] = A[i] + B[i];
     else if(i<2048) C[i] = A[i] * B[i];
     else if(i<3072) C[i] = A[i] - B[i];
     else if(i<4096) C[i] = A[i] / B[i];
}

void CPUfunction(float *A, float *B, float *C){
     int i;

     for(i=0; i<1024; i++)              C[i] = A[i] + B[i];
     for(i=1024; i<2048; i++)         C[i] = A[i] * B[i];
     for(i=2048; i<3072; i++)         C[i] = A[i] - B[i];
     for(i=3072; i<4096; i++)         C[i] = A[i] / B[i];
}

int main(){
     int i;
     float A[4096], B[4096], C[4096];
     float *hA, *hB, *hC;
     float *dA, *dB, *dC;
     int size = 4096 * sizeof(float);

     hA = (float*)malloc(size);
     hB = (float*)malloc(size);
     hC = (float*)malloc(size);

     cudaMalloc((void**)&dA, size);
     cudaMalloc((void**)&dB, size);
     cudaMalloc((void**)&dC, size);

     /* initialize */
     srand(time(0));
     for(i=0;i<4096;i++){
          A[i] = hA[i] = rand() % 40;
          // make sure that B is not zero
          B[i] = hB[i] = rand() % 39 + 1;
     }

     /* GPU code */
     cudaMemcpy(dA, hA, size, cudaMemcpyHostToDevice);
     cudaMemcpy(dB, hB, size, cudaMemcpyHostToDevice);
     GPUfunction<<<8, 512>>>(dA, dB, dC);
     cudaMemcpy(hC, dC, size, cudaMemcpyDeviceToHost);

     /* CPU code */
     CPUfunction(A, B, C);

     /* check answers from CPU and GPU are same */
     for(i=0;i<4096;i++){
          if(!floatIsEqual(C[i], hC[i])){
               printf("Compute Error\n");
               break;
          }
     }
     if(i==4096) printf("Corrected Answer\n");

     free(hA);
     free(hB);
     free(hC);

     cudaFree(dA);
     cudaFree(dB);
     cudaFree(dC);

     return 0;
}

ทำการคอมไพล์โปรแกรมด้วยคำสั่ง

$nvcc  program2.cu –o program2

ได้ผลลัพท์ออกมาเป็น Corrected Answer ซึ่งหมายถึงโปรแกรมทำงานได้ถูกต้อง การคำนวนแบบขนานจากจีพียูให้ผลลัพท์ตรงตามการคำนวนจากซีพียู

GPUfunction :

__global__ void GPUfunction(float *A, float *B, float *C){
     int i = blockIdx.x * blockDim.x + threadIdx.x;
     __shared__ float ssuma[512];
     float sum;
     int s, tid = threadIdx.x;

     /* copy global mem to shared mem synchonously */
     ssuma[tid] = A[i];
     __syncthreads();

     /* parallel reduction */
     for(s=256; s>0; s/=2){
          if(tid<s)  ssuma[tid] = ssuma[tid] + ssuma[tid+s];
          __syncthreads();
     }
     sum = ssuma[0];

     if(i<1024)        C[i] = sum + B[i];
     else if(i<2048) C[i] = sum * B[i];
     else if(i<3072) C[i] = sum - B[i];
     else if(i<4096) C[i] = sum / B[i];
}

CPUfunction :

void CPUfunction(float *A, float *B, float *C){
     int i;
     float SUMA[8];

     /* initialize SUMA */
     for(i=0;i<8;i++)           SUMA[i] = 0.0;
     for(i=0;i<4096;i++)     SUMA[i/512] += A[i];

     for(i=0; i<1024; i++)
          C[i] = SUMA[i/512] + B[i];
     for(i=1024; i<2048; i++)
          C[i] = SUMA[i/512] * B[i];
     for(i=2048; i<3072; i++)
          C[i] = SUMA[i/512] - B[i];
     for(i=3072; i<4096; i++)
          C[i] = SUMA[i/512] / B[i];

}

ทำการคอมไพล์โปรแกรมด้วย nvcc โดยใช้คำสั่ง

$nvcc  program3.cu –o program3

ซึ่งเมื่อรันโปรแกรมแล้วให้ผลลัพท์ถูกต้อง และแสดงข้อความว่า Corrected Answer เช่นเดียวกันในข้อ 2

ดาวน์โหลดโปรแกรมทั้ง 3 โปรแกรมได้ที่ด้านล่าง
program 1
program 2
program 3

2. ติดตั้ง CUDA Toolkit ด้วยคำสั่ง sh cudatoolkit_2.3_linux_64_ubuntu9.04.run จากนั้นโปรแกรมจะถามถึง path ที่ต้องการจะใช้ติดตั้ง พิมพ์ /tmp/4909611727 ลงไป

3. คอมไพเลอร์ของ CUDA หรือ nvcc นั้นจะเก็บไว้ที่ /tmp/4909611727/cuda/bin ให้ตั้งค่าของ $PATH และ $LD_LIBRARY_PATH ดังนี้

      export PATH=/tmp/4909611727/cuda/bin:$PATH
      export LD_LIBRARY_PATH=/tmp/4909611727/cuda/lib64:$LD_LIBRARY_PATH

4. ทดสอบว่าสามารถใช้งาน nvcc ได้ด้วยการพิมพ์คำสั่ง nvcc –version ซึ่งจะได้ผลลัพท์ดังนี้

5. ติดตั้ง NVIDIA CUDA SDK ด้วยคำสั่ง sh cudasdk_2.3_linux.run โปรแกรมจะถามถึง path ที่จะใช้ติดตั้ง ซึ่งถ้าไม่ใส่จะถูกกำหนดให้เป็น NVIDIA_GPU_Computing_SDK แต่ในที่นี้จะกำหนดให้เป็น /tmp/4909611727/NVIDAI_CUDA_SDK

6. คอมไพล์ไฟล์ตัวอย่างที่มากับ NVIDIA CUDA SDK ด้วยการเข้าไปที่ /tmp/4909611727/NVIDIA_CUDA_SDK/C แล้วใช้คำสั่ง make

7. ทดสอบโปรแกรมด้วยการรันโปรแกรมตัวอย่างที่อยู่ที่ /tmp/4909611727/NVIDIA_CUDA_SDK/C/bin/linux/release ซึ่งโปรแกรมตัวอย่างที่จะทดสอบคือ deviceQuery และ bandwidthTest

deviceQuery

โปรแกรม deviceQuery เป็นโปรแกรมที่ใช้แสดงคุณลักษณะของกราฟิกการ์ดที่ใช้ ซึ่งผลลัพธ์จากการรันโปรแกรม deviceQuery เป็นดังต่อไปนี้

bandwidthTest

โปรแกรม bandwidthTest จะแสดงให้เห็นถึงความสามารถในการส่งข้อมูลแบบต่างๆระหว่างหน่วยความจำหลัก และหน่วยความจำ Global ของ GPU ทดสอบโดยการส่งข้อมูลขนาด 32 MB ผลได้เป็นดังโปรแกรม

Vector Addition

เขียนโปรแกรมบวกเวกเตอร์ เซฟด้วยชื่อไฟล์ vecadd.cu แล้วทำการคัดลอกไปยังเครื่องเซิฟเวอร์ และคอมไพล์ด้วยคำสั่ง nvcc vecadd.cu และรันโปรแกรมจะได้ผลลัพท์ออกมาดังนี้

โค้ดของโปรแกรมนี้คือ

#include <stdio.h>
__global__ void VecAdd(float *A, float *B, float *C, int N){
	int idx = (blockIdx.x * blockDim.x) + threadIdx.x;

	if(idx<N){
		C[idx] = A[idx] + B[idx];
	}
}
int main(){
	float *h_A, *h_B, *h_C;
	float *d_A, *d_B, *d_C;
	int N = 200000;
	int size = sizeof(float) * N;
	int threadPerBlock = 512;
	int blockPerGrid = (N + threadPerBlock -1) / threadPerBlock;

	// Allocate host and device memory
	h_A = (float*)malloc(size); h_B = (float*)malloc(size); h_C = (float*)malloc(size);
	cudaMalloc((void**)&d_A, size); cudaMalloc((void**)&d_B, size); cudaMalloc((void**)&d_C, size); 

	// Initial value on vector A and B
	for(int i=0;i<N;i++)
		h_A[i] = rand()/200, h_B[i] = rand()/200;

	// Copy vector A and B to device
	cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice);
	cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice);

	// Call kernel
	VecAdd<<< blockPerGrid, threadPerBlock >>>(d_A, d_B, d_C, N);

	// Copy back vector C
	cudaMemcpy(h_C, d_C, size, cudaMemcpyDeviceToHost);

	printf("%s\n", cudaGetErrorString( cudaGetLastError() ) );
	printf("Threads per block = %d\nBlocks per grid = %d\n", threadPerBlock, blockPerGrid);
	printf("Vector size = %d\nMemory used = %f MB\n", N, 3 * size / 1024.0 / 1024);

	// Deallocate host and device memory
	free(h_A); free(h_B); free(h_C);
	cudaFree(d_A); cudaFree(d_B); cudaFree(d_C);

	return 0;
}

ปกติแล้วการเชื่อมต่ออุปกรณ์และเครื่องคอมพิวเตอร์ต่างๆเข้าด้วยกันนั้นจะอาศัย Switch (Physical Switch) และบน Switch ก็จะมี Port (Physical Port) ที่จะรอรับสายแลนจาก Network Interface Card (Physical NIC) ที่ซึ่งอยู่บนอุปกรณ์ และคอมพิวเตอร์แต่ละตัว

จากโมเดลการทำงานนี้เอง VMware ESXi ก็จะจำลอง Network ขึ้นมาด้วยวิธีเดียวกัน โดยมีส่วนประกอบคือ

• Virtual Switch ซึ่งใน ESXi จะเรียกว่า vSwitch เป็นตัวที่จำลองการทำงานของ Switch ขึ้นมา แล้วอยู่ภายใต้การดูแลการทำงานของ VMkernel
• Virtual NIC ซึ่งใน ESXi จะเรียกว่า vNIC จะมีอยู่ในทุกเครื่องของ Virtual Machine และเชื่อมต่อกับ Virtual Switch โดยผ่าน Virtual Port
• Virtual Port เป็นตัวเชื่อมต่อระหว่าง Virtual NIC ของแต่ละ Virtual Machine กับ Virtual Switch

Virtual Machine แต่ละเครื่องที่อยู่บน VMware ESXi จะใช้ Physical NIC เป็นทางเชื่อมกับโลกภายนอก ด้วยการใช้bridge โดยที่ใน Physical NIC นั้นจะไม่มี IP Address แต่ IP Address จะขึ้นกับ Virtual NIC ในแต่ละเครื่องของ Virtual Machine แทน    Physical NIC นั้นเพียงแต่ทำหน้าที่เป็นทางผ่านของข้อมูลระหว่าง Physical Switch ที่อยู่ภายนอก และ Virtual Switch ที่อยู่ภายใน คล้ายกับการ Uplink ระหว่าง Switch (ดังนั้น Port ที่ต่อระหว่าง Physical NIC กับ Virtual Switch จึงถูกเรียกว่า Uplink Port )

Virtual Switch ที่ถูกสร้างขึ้นบน VMware ESXi สามารถจำลองขึ้นมาได้มากที่สุดถึง 127 เครื่อง และ Virtual Switch แต่ละเครื่องที่ยังสามารถมี Virtual Port ได้ถึง 1016 พอร์ต แต่บน ESXi ทั้งหมดรวมกันนั้นจะต้องมีไม่เกิน 4096 พอร์ต

อ้างอิงจาก

http://www.compspot.net/index.php?option=com_content&task=view&id=366&Itemid=72

ส่วนประกอบของ VMware ESXi มีดังต่อไปนี้

VMkernel – อยู่ใน Layer ชั้นล่างสุดของระบบ มีหน้าที่และฟังก์ชันการทำงานคล้ายกับระบบปฎิบัติการ เช่น การสร้าง Process, การควบคุม Process, การส่ง Signal, การจัดการระบบ file system, การสร้าง Thread     ถูกออกแบบมาเพื่อให้สามารถรองรับการทำงานของ Virtual Machine หลายเครื่องพร้อมกันได้ ด้วยฟังก์ชันการทำงานต่อไปนี้

• Resource scheduling
• I/O stacks
• Device driver

VMkernel จะคอบควบคุมการทำงานของ Hardware device บนเครื่อง Server และคอยควบคุมการจัดแบ่ง resource ต่างๆให้กับ Guest VM แต่ละตัว

Direct Console User Interface (DCUI) – เป็น interface ที่ใช้ในการ configure และจัดการตั้งค่าพื้นฐานต่างๆที่สำคัญของระบบในเครื่อง server สามารถติดต่อกับ DCUI ได้โดย console ของเครื่อง server เท่านั้นไม่สามารถทำกำหนดค่าผ่าน Network ได้ ตัว DCUI นั้นจะเป็นตัวกำหนดค่าต่างๆและคอยแก้ใขข้อผิดพลาดในระบบ เช่น

• กำหนด administrative password
• กำหนดค่า Network ต่างๆ ถ้าหากไม่สามารถกำหนดอัตโนมัติด้วย DHCP ได้
• จัดเตรียมการทดสอบระบบ Network อย่างง่ายไว้ให้
• ใช้สำหรับดู Log file
• ใช้ Restart server
• ใช้ Restore ค่า default ของระบบ

Virtual Machine Monitor (VMM) – เป็น process ที่จำลองพื้นที่และสภาพแวดล้อมการทำงานให้แต่ละ Guest OS โดยมี helper process ชื่อ VMX เป็นของ guest OS แต่ละตัว ดังนั้นในแต่ละ Guest OS จะต้องมี VMM และ VMX คู่กันเสมอ

Common Information Model (CIM) – เป็น Interface ที่ใช้ในการจัดการในระดับ hardware กับเครื่อง guest OS ผ่าน remote application ซึ่งจะมีชุดของ API ที่เป็นตัวรองรับอยู่ CIM นั้นเป็น Open standard ในการแสดงและจัดการ resource และ hardware ของเครื่อง ซึ่ง CIM Framework มีส่วนประกอบคือ

• CIM provider หรือเรียกว่า  CIM object manager เป็นส่วนที่จัดเตรียมการเข้าถึง device driver และ hardware บนเครื่อง ผู้ผลิต hardware นั้นสามารถเขียนตัว provider ที่จะใช้จัดการกับ hardware นั้นขึ้นมาเองได้  ESXi ได้สร้างมาตรฐาน CMPI ที่ยอมให้นักพัฒนาสามารถเขียน provider ตัวใหม่และสามารถนำมาต่อใช้งานได้ แต่จะต้องถูกรวมเข้าไปกับ system image เลย ไม่สามารถนำมาติดตั้งในขณะรันได้
• CIM broker ทำหน้าที่คอบนำข้อมูลจากทุก CIM providers และแสดงสู่โลกภายนอก ผ่าน API มาตรฐาน เช่น WS-MAN

Other User World Processes – process ที่ซึ่งถูกเรียกใช้โดย VMware เพื่อย้ายความสามารถในการควบคุมที่อยู่บนเครื่อง server ไปยัง user world

• hostd เป็น process ที่จะเตรียม programmatic interface ให้กับ VMkernel และถูกใช้ด้วย VI Client ได้เหมือนกับ VI API    ซึ่ง hostd จะทำหน้าที่ยืนยันผู้ใช้แต่ละคน พร้อมกับเก็บสิทธิการเข้าถึง ว่าผู้ใช้คนนั้นสามารถจัดการอะไรบนระบบได้บ้าง
• vpxa เป็น process ที่จะสามารถติดต่อไปยัง VirtualCenter และจะรันโปรแกรมพิเศษที่เรียกว่า vpxuser ที่จะเป็นตัวกลางระหว่าง hostd และ VirtualCenter
• syslog เป็น daemon process ที่ทำงานบน user world เช่นกัน มีหน้าที่เก็บ log เมื่อเปิดให้ระบบเก็บ remote logging

Open Network Ports – มี Port จำนวนหนึ่งที่ถูกเปิดอยู่ตลอดเวลาบน ESXi ซึ่งเป็น Port ที่สำคัญในการทำงานได้แก่

• 80 – เป็น server port  ที่จะแสดง static webpage  เพื่อใช้สำหรับการ browse มาที่ server และ port นี้จะถูก redirect ไปยัง port 443 เพื่อให้ client ติดต่อกับ server ผ่าน SSL
• 443 – port นี้มีไว้สำหรับ client ติดต่อกับ server ผ่าน SSL เพื่อเรียกใช้ service ต่างๆ ได้แก่ VMware Virtual Infrastructure API(VI API)ที่ซึ่งสามารถเข้าใช้งาน RCLIs, VI client, Virtual center server และ SDK
• 427 – port นี้มีไว้เพื่อเข้าใช้งาน service location  protocol ซึ่งเป็น protocol ที่ใช้ค้นหา VI API
• 5989 – port นี้เปิดไว้สำหรับ CIM server ที่จะเป็น interface สำหรับ toolที่ใช้ในการจัดการ
• 902 – port นี้เปิดไว้สำหรับ support VIM API version ก่อนหน้า

File System – VMkernel จะเก็บข้อมูลของ configuration files, log files, staged patches ไว้เป็นแบบ file  ที่อยู่บน memory และเพื่อให้ง่ายต่อการใช้งาน โครงสร้างของ file system จึงออกแบบมาให้เหมือนกับที่ใช้บนเครื่อง server ของ ESX เช่น

• /etc/vmware สำหรับเก็บ ESXi configuration files
• /var/log/vmware สำหรับเก็บ log files
• /tmp สำหรับเก็บ staged patches

ตัว file system นี้จะเป็นอิสระจาก VMware VMFS file system ที่เป็นตัวเก็บ Virtual Machine เนื่องจาก VMFS จะถูกเก็บลงบน Disk บน host หรือบน shared storage

สามารถใช้ remote command line เพื่อจัดการกับ file system ทั้งที่อยู่บน memory และ VMware VMFS file system ได้ โดยผ่านการใช้ HTTPS get และ put

นอกจากนี้ข้อมูลที่อยู่ใน file system บน memory นั้นจะไม่อยู่อย่างถาวร เมื่อเครื่องถูกปิด ข้อมูลทั้งหมดก็จะหายไป ดังนั้น ESXi จึงมีความสามารถที่จะสั่งงานให้เก็บข้อมูลของ log ลงบน Disk ได้ผ่านทาง remote syslog server

User and Groups – User และ Group ถูกกำหนดไว้บน  ESXi server ซึ่งแต่ละคนจะสามารถเข้าสู้ระบบได้ผ่านทาง remote command line หรือ VIM API

Group นั้นประกอบจาก User หลายคน เหมือนกับระบบปฏิบัติการทั่วไป จะใช้ Group เช่น ต้องการกำหนเสิทธิให้กับ User หลายๆคนพร้อมกันในครั้งเดียว

Administrative privileges สามารถกำหนด User แต่ละคนว่าจะอยู่ที่ Group ไหนได้ ข้อมูลของ User และ Group นั้น ถูกเก็บไว้ที่ /etc/passwd, /eyc.shadow และ /etc/group และเหมือนกับระบบปฏิบัติการ Linux และใช้ฟังก์ชันมาตรฐาน crypt ในการเข้ารหัส

User Worlds – คำว่า  User Worlds นั้นหมายถึง process ที่ทำงานอยู่บน VMkernel แต่สิ่งแวดล้อมของระบบที่ User World ทำงานด้วยนั้นมีจำกัดเมื่อเทียบกับระบบปฎิบัติการทั่วไปอย่าง Linux เช่น

• จำนวนของ Signal ที่มีให้นั้นจำกัด
• API ของระบบนั้นเป็นเพียง subset ของ POSIX
• /proc file system นั้นจำกัดไว้มาก
• Swap file มีเพียงตัวเดียวให้ใช้ร่วมกันระหว่างหลาย User world process

อ้างอิงจาก

http://www.vmware.com/files/pdf/vmware_esxi_architecture_wp.pdf

1. ติดต่อเครื่อง Server ผ่าน vSphere client ตามขั้นตอนที่ได้กล่าวไปก่อนหน้านี้ เมื่อ Log in เรียบร้อยแล้ว จะได้หน้าจอดังภาพ ให้เลือกที่เมนู “Create a new virtual machine” เพื่อสร้าง Virtual Machine เครื่องใหม่ขึ้นมาบนระบบ

2. เลือก Configuration ให้เป็น Typical แล้วกด Next

3. ตั้งชื่อเครื่อง Virtual Machine ที่สร้างขึ้นใหม่แล้วกด Next (ซึ่งในที่นี้จะตั้งชื่อว่า WindowsXP)

4. ทำการเลือก Datastore ที่ต้องการ แล้วกด Next

5. เลือกชนิดและเวอร์ชันของ Guest OS ที่ต้องการจะลงบนเครื่อง Virtual Machine ที่ส้รางขั้นใหม่ แล้วกด Next (ในที่นี้เลือกเป็น Microsoft Windows XP Professional 32 bit)

6. ทำการสร้าง Disk จำลองขึ้นบน Virtual Machine ให้เลือกขนาดของ Disk โดยจะต้องไม่เกิน Available space

7. เมื่อกำหนดค่าต่างๆของเครื่อง Virtual Machine เสร็จแล้ว จะปรากฎหน้าจอดังภาพ ให้กดที่ Finish

8. เมื่อได้ Virtual Machine เครื่องใหม่แล้ว ให้ทำการกำหนดค่าของฮาร์ดแวร์ต่าง ด้วยการคลิ๊กขวาที่ Virtual Machine นั้นแล้วเลือก Properties เลือกในส่วนของ CD/DVD Drive1 ติ๊กที่ “Connect at power on” เลือก Device Type เป็นแบบ “Host Device” ซึ่งหมายถึงให้ใช้ฮาร์ดแวร์จากเครื่อง Server ให้ให้ติดต่อทันที่ที่เปิดใช้งาน Virtual Machine นี้ จากนั้นทำการใส่แผ่น install ของ Microsoft Windows XP เข้าไปที่เครื่อง Server

9. เมื่อใส่แผ่น install แล้ว ที่หน้าจอหลักให้เลือกที่เมนู “Power on the virtual machine”

10. คลิ๊กขวาที่เครื่องที่ทำการ install แล้วเลือกที่ Open console เพื่อเปิดหน้าต่างควบคุมการทำงาน

11. เมื่อเลือกแล้วจะขึ้นหน้าต่างการทำงานของเครื่อง Virtual Machine นั้น

12. ทำการติดตั้ง OS เหมือนกับที่ติดตั้งบนเครื่องปกติ ซึ่งภาพหน้าต่างด้านข้างแสดงถึง การติดตั้ง Microsoft Windows XP

13. เมื่อติดตั้งเสร็จก็พร้อมใช้งานได้เสมือนกับทำงานกับเครื่องจริง

2. VMware จะเริ่มทำการ load ให้รอสักครู่

3. กด Enter เพื่อเลือกที่จะ Install

4. กด F11 เพื่อยอมรับข้อตกลง

5. ทำการเลือก Partition ที่ต้องการ install และกด Enter

6. เลือก F11 เพื่อยืนยันการ install

7. ระบบจะทำการ install ให้รอสักครู่

8. เมื่อ install เสร็จสิ้นจะปรากฏหน้าจอดังภาพ ให้นำแผ่นออก จากนั้นกด Enter เพื่อให้ระบบ Restart

9. เมื่อเปิดเครื่องขึ้นมาใหม่จะได้หน้าจอดังภาพ ให้กด F2 เพื่อทำการกำหนดค่าในระบบ

10. เลือกที่ Configure Password แล้วกด Enter เพื่อทำการตั้ง Password ใหม่

11. ใส่ Password ในช่อง Old Password และ New Password ตามที่ต้องการแล้วกด Enter

12. จากนั้นเลือกที่ Configure Management Network จะได้หน้าจอดังภาพ ให้ทำการเลือก IP Configuration เพื่อกำหนดค่า IP ของเครื่อง server ใหม่

13. เลือกที่ Set static IP address and Network Configuration และทำการเปลี่ยน IP ของเครื่อง server ในส่วนนี้ต้องระวังเรื่องของ subnet mark ด้วย เมื่อตั้งค่าเสร็จแล้วให้กด Enter

14 . เข้าไปที่ DNS Configuration แล้วทำการแก้ในส่วน Primary DNS Server ให้ตรงกับที่ตั้งค่าไว้ก่อนหน้านี้ และทำการเปลี่ยน hostname ตามที่ต้องการ จากนั้นกด Enter เพื่อตกลง

15. กด Esc เพื่อออกจากการ configuration ระบบจะถามว่าต้องการ restart management network หรือไม่ให้กด Y เพื่อตอบตกลง

16. ไปที่เครื่อง Client ที่จะเป็นเครื่องที่จะ remote เข้ามาเพื่อควบคุมการทำงานของเครื่อง server ให้เปิด web browser ขึ้นมาจากนั้นเข้าไปที่ https:// ตามด้วย static IP ของเครื่อง server  ตามที่ได้ตั้งไว้ จะปรากฎหน้าเว็บไซต์ดังภาพ ให้ทำการดาวน์โหลด vSphere Client จากลิงค์ที่ปรากฏบนเว็บ เพื่อในมาลงที่เครื่อง Client

17. ทำการ Install vSphere client

18. เมื่อ Install เสร็จแล้ว ให้เปิดโปรแกรม vSphere client จากนั้นให้ใส่ IP ของเครื่อง server แล้วใส่ Username เป็น root ตามด้วยใส่ Password ที่ตั้งไว้ก่อนหน้านี้

19. เมื่อติดต่อกับเครื่อง server ได้แล้ว โปรแกรม vSphere client จะปรากฏหน้าจอดังภาพ