สถาปัตยกรรมคอมพิวเตอร์แบบ SIMD

[ Post : 24 May 1999 ]

งานๆหนึ่ง ถ้าใช้คนงานช่วยกันทำ 1 คน ทำงาน ใช้เวลา 100 หน่วยเวลา แต่หากว่า ให้มีผู้ช่วย มาช่วยทำงานก็จะลดเวลาเหลือเพียง 50 หน่วยเวลา แล้วถ้ามีคนมาช่วยกันทำถึง 100 คน เวลาที่จะทำงานให้สำเร็จนั้น ก็เหลือเพียงแค่ 1 หน่วยเวลา ... ทฤษฎีนี้ เป็นไปได้ไหม?

จะว่าเป็นไปได้ ก็ใช่ เพราะหลายๆคนช่วยกันทำงานงานก็จะสำเร็จเร็วขึ้น แต่ จะว่าเป็นไปไม่ได้ ก็ใช่เช่นกัน เพราะว่า การทำงานนั้น บางที ก็ต้องรอผลของอีกขั้นตอนหนึ่งก่อน เพื่อจะมาใช้ในขั้นตอนที่จะทำงานต่อไป เพราะฉะนั้น ให้ 100 คนทำ ก็อาจทำไม่สำเร็จได้ในเวลาเพียง 1 หน่วยเวลา

แนวความคิดนี้ ก็ถูกนำมาพัฒนาใช้กับการทำงานของการประมวลผลของคอมพิวเตอร์เช่นกัน ... กล่าวคือ ถ้าหากว่า ถ้าให้ CPU ทำการประมวลผล แบบตามลำดับ คือ ทีละ 1 คำสั่ง เพราะฉะนั้น ถ้ามีข้อมูลมา 100 ชุด ก็จะใช้เวลา 100 หน่วยเวลา แต่ถ้าหากว่า มีหลายๆ CPU มาช่วยกันทำงานล่ะ ก็น่าจะลดเวลาการทำงานให้เสร็จลงใช่ไหม?

คำตอบก็เหมือนกับการทำงานของคนข้างต้น ... ตัวอย่างเหล่านี้ คือ concept หรือ แนวคิด ของการทำงาน หรือ การประมวลผลแบบขนาน ซึ่งในคราวนี้ เราจะมาพูดถึงกันในเรื่องของสถาปัตยกรรมแบบ SIMD ซึ่ง ก็จัดเป็นประเภทการประมวลผลแบบขนานแบบหนึ่ง

SIMD คืออะไร?

SIMD หรือ Single Instruction Multiple Data stream หรือ กล่าวคือ เป็นการประมวลผลแบบที่มีข้อมูลเข้ามาหลายๆ ชุด โดยใช้คำสั่งในการประมวลผล เพียงชุดคำสั่งเดียว และได้ผลลัพธ์ออกมาหลายๆผล ( เพราะมีหลายชุดข้อมูล ) ลองดูจากรูปนะครับ



มันทำงานอย่างไร?

เอาละครับ มาถึงตรงนี้ก็คงจะเริ่มงงๆกันแล้วใช่ไหมครับ ว่า ถ้าอย่างนี้แล้ว มันจะมีดีอย่างไร เอาอย่างนี้ก็แล้วกันนะครับ เราจะมาดูตัวอย่างในการใช้งานของมันกันนะครับ ลองนึกถึงการคูณ Matrix กันสักหน่อยนะครับ ( คิดว่าทุกๆท่านคงรู้จัก Matrix กันมาบ้างแล้วนะครับ ... ไม่ใช่ภาพยนตร์ที่คีนูรีฟแสดงนะครับ :-P )

ถ้าผมต้องการคูณ Matrix A เข้ากับ Matrix B เพื่อให้ได้ผลลัพธ์ คือ Matrix C ดังรูปนะครับ



โดยค่าของ Matrix C นั้นจะได้มาจาก ผลคูณและ ผลบวกของ Matrix A และ B ดังนี้ครับ

c11 = ( a11 * b11 ) + ( a21 * b12 ) + ( a31 * b13 )

ซึ่งก็คือ ค่าของ Matrix C ตัวแรก ( แถวที่ 1 หลักที่ 1 ) นั้น มาจาก ผลบวก ของผลคูณจากแถวที่ 1 ของ Matrix A กับ หลักที่ 1 ของ Matrix B และ ในทำนองเดียวกัน สำหรับค่าของ C ตัวที่สอง ( แถวที่ 1 หลักที่ 2 ) ก็จะมาจาก ผลบวกของผลคูณของแถวที่ 1 ของ Matrix A กับ หลักที่ 2 ของ Matrix B ดังนี้ครับ

c21 = ( a11 * b21 ) + ( a21 * b22 ) + ( a31 * b23 )

ถ้าให้ทำการคูณ Matrix ดังกล่าว ก็ลองคิดดูนะครับ ว่าจะต้องใช้เวลาในการทำงานเท่าไร ถ้าค่อยๆทำทีละ ชุดข้อมูล และ ชุดคำสั่ง ...

ดูกันง่ายๆ กันก่อนก็ได้ครับ สำหรับการหาค่า ของ c11 ถ้าผมกำหนดให้การคูณนั้นใช้เวลาในการประมวลผลคือ 4 หน่วยเวลา และ การบวกเป็น 1 หน่วยเวลา

เพราะฉะนั้นการทำงานแบบปกติ หรือ ทำตามลำดับขั้น ก็จะต้องเสียเวลาในการคูณ 3 ครั้ง ก็คือ a11*b11 และ a21*b12 และ a31*b13 ซึ่งก็จะใช้เวลา ไปทั้งสิ้น 3*4 = 12 หน่วยเวลา และ ยังต้องเสียการบวกอีก 2 ครั้ง เพราะในการบวก ต้องบวกทีละ 2 ค่า ไม่สามารถบวกครั้งเดียวด้วยค่า 3 ค่าได้ ก็จะเสียเวลาในการบวกอีก 1*2 = 2 หน่วยเวลา เพราะฉะนั้น ก็จะใช้เวลาในการหาค่าของ c11 ทั้งสิ้น 14 หน่วยเวลา ซึ่งสำหรับ Matrix นี้ เป็น Matrix ที่มีขนาด 3x3 คือ จะมีสมาชิกทั้งหมด 9 ตัว เพราะฉะนั้น ก็จะใช้เวลาในการหาผลคูณทั้งหมด 9*14 = 126 หน่วยเวลาเลยทีเดียว

ทีนี้เราลองมาดูการประมวลผลของสถาปัตยกรรมแบบ SIMD กันบ้าง สถาปัตยกรรมแบบนี้นั้น อย่างที่กล่าวมาแล้ว ก็คือ จะสามารถประมวลผล ด้วยชุดข้อมูลหลายๆชุด ซึ่งไม่เกี่ยวข้องกัน ด้วยคำสั่งเดียวกันได้พร้อมๆกันเลย เพราะฉะนั้น การคูณก็จะทำได้พร้อมๆกันเลยทั้ง 3 ค่า คือสามารถหาค่าขอ a11*b11และ a12*b12 และ a31*b13 ได้ในเวลาเดียวกันเลยครับ เพราะฉะนั้นเวลาที่ใช้ ในการคูณ 3 ค่านี้ ก็คือ 4 หน่วยเวลาเท่านั้น และสำหรับการบวก ก็ยังคงต้องใช้ 2 ครั้ง เพราะไม่ว่าจะบวกยังไง ก็ไม่สามารถบวกกันทีละ 3 ค่าได้ และ ที่สำคัญก็คือ 3 ค่านั้น แบ่งกันบวกทีละ 2 ก็ไม่ได้ เพราะฉะนั้น ก็ต้องเสียเวลาอีก 2 ครั้งคือ 1*2 = 2 หน่วยเวลา สรุปก็คือจะใช้เวลาในการหาค่าหนึ่งๆ คือ 4+2 = 6 หน่วยเวลาเท่านั้นเอง และหากเป็นการหาค่าของทั้ง Matrix ทั้ง 9 ตัว ก็สามารถใช้เวลาในการคูณค่าทั้งหมดเพียง 4 เท่านั้น แล้วก็เสียเวลาในการบวก เพียง 2 เท่านั้น เช่นกันครับ เพราะว่าทำงานด้วยคำสั่งเดียวกัน แต่ต่างชุดข้อมูลกัน และ ข้อมูลนั้นไม่เกี่ยวเนื่องกัน เพราะฉะนั้น ผลคูณของทั้ง Matrix ก็จะสามารถหามาได้เพียงแค่ 6 หน่วยเวลา เลยด้วยซ้ำ

ครับนี่ก็เป็นตัวอย่างคร่าวๆ สำหรับการประมวลผลของสถาปัตยกรรมแบบ SIMD นะครับ ซึ่งก็ดูแล้ว ให้ผลที่เร็วขึ้นมากๆ เลย แต่ ในความเป็นจริงนั้น ก็่ใช่ว่าจะสามารถทำได้เช่นนี้จริงๆ เพราะ การที่จะทำเช่นนี้ได้นั้น ( เช่นจากตัวอย่าง การคูณพร้อมๆกันทีละหลายๆ ตัว ) ก็ต้องใช้หน่วยความจำ และ Register มากๆ ซึ่งแน่นอน CPU ไม่รองรับถึงขนาดมากๆ เช่นนั้นหล่ะครับ มันก็จะมี Limit ของมัน ทำให้ผลที่ได้ ก็ไม่ได้ดีถึงระดับตามทฤษฎี จากตัวอย่างข้างต้นละนะครับ

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

A = B + C และ
D = C + A

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

เอาไปใช้งานได้อย่างไร?

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

ผมเคยเขียน Program การหมุนภาพ Bitmap แบบ 2 มิติ ก็ใช้วิธีการคูณ Matrix นี่หล่ะครับ ในการทำการหมุนภาพ ซึ่งตรงนี้จะไม่ขออธิบายเรื่องของการ coding ละนะครับ เพราะจะนอกเรื่องเอา แต่หากว่าสนใจ ก็จะนำมาเสนอให้ทราบกันต่อไปครับ

ก็ขอยกตัวอย่างเรื่องการนำไปใช้งาน ด้านเดียวก่อนนะครับ ( แหะๆ นึกออกตอนนี้ ที่เด่นชัด ก็มีเรื่องนี้หล่ะครับ )

สถาปัตยกรรมที่เกี่ยวข้อง

ไหนๆ ก็ไหนๆ แล้ว ก็ขอกล่าวเพิ่มเติมเกี่ยวกับสถาปัตยกรรมที่เกี่ยวข้องกับ SIMD สักหน่อยนะครับ เพราะต่างก็เป็นประเภทของสถาปัตยกรรมการประมวลผลแบบขนาน ที่ Flynn เป็นผู้นำเสนอทั้งสิ้นครับ

เอาละครับ สำหรับเรื่องของ SIMD นี้ ผมก็คงต้องขอจบเพียงเท่านี้ก่อน หากมีข้อผิดพลาด หรือ ข้อเสนอแนะ ประการใด ก็ e-mail มาแนะนำกันได้ครับ ยินดีรับฟัง ครับ :-) และ หากมีข้อมูลเพิ่มเติม ก็จะนำมาลงให้อ่านกันต่อไปครับ