การพัฒนาซอฟต์แวร์คำนวณทางวิทยาศาสตร์แบบขนาน

ฉันต้องการพัฒนาซอฟต์แวร์การคำนวณทางวิทยาศาสตร์แบบขนานตั้งแต่เริ่มต้น ฉันต้องการความคิดเกี่ยวกับภาษาที่จะเริ่มต้น โปรแกรมนี้เกี่ยวข้องกับการอ่าน / เขียนข้อมูลไปยังไฟล์ txt และทำการคำนวณอย่างหนักพร้อม ๆ กันโดยมี factorizations LU จำนวนมากและการใช้ตัวแก้ปัญหาเชิงเส้นแบบกระจัดกระจาย ทางเลือกที่ฉันคิดคือ Fortran 2003/2008 กับ OpenMP หรือ co-array, C ++ กับ openmp cilk + หรือ TBB, python ข้อเสนอแนะอื่น ๆ เอกสารยินดีต้อนรับ! ฉันรู้ดีมาก C, Fortran และ Java (ตามลำดับ) ฉันได้ทำสคริปต์บางอย่างในหลาม แต่เป็นสิ่งพื้นฐาน

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

ซอฟต์แวร์ต้องสามารถจัดการข้อมูลจำนวนมากและมีประสิทธิภาพด้วยการคำนวณทางวิทยาศาสตร์ ประสิทธิภาพเป็นสิ่งสำคัญ

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

Petros

ให้ฉันลองและทำลายความต้องการของคุณ:

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

จากรายการนี้ฉันจะพิจารณาภาษาต่อไปนี้:

C, C ++, Fortran, Python, MATLAB, Java

จูเลียเป็นภาษาใหม่ที่มีแนวโน้ม แต่ชุมชนยังคงมีอยู่รอบตัวมันและมันไม่ได้ถูกปรับใช้ในรหัสใหม่ที่สำคัญ

การอ่าน / เขียนข้อมูลข้อความ

ง่ายต่อการเข้าใจในการเขียนโปรแกรมภาษาใด ๆ ตรวจสอบให้แน่ใจว่าคุณได้บัฟเฟอร์อย่างเหมาะสมและรวมการเข้าถึง I / O ของคุณและคุณจะได้รับประสิทธิภาพที่ดีจากภาษาใด ๆ ที่คุณควรพิจารณา หลีกเลี่ยงวัตถุสตรีมใน C ++ เว้นแต่คุณจะรู้วิธีใช้วัตถุเหล่านั้นอย่างมีประสิทธิภาพ

อินเทอร์เฟซ / ความสามารถที่แข็งแกร่งสำหรับ LU factorizations

หากคุณกำลังดำเนินการกับปัจจัยที่หนาแน่นของ LU คุณจะต้องใช้ LAPACK หรือ ScaLAPACK / Elemental สำหรับการทำงานแบบขนาน LAPACK และ ScaLAPACK ถูกเขียนใน Fortran ส่วน Elemental นั้นเขียนด้วย C ++ ทั้งสามไลบรารีนั้นมีประสิทธิภาพและได้รับการสนับสนุนและจัดทำเป็นเอกสาร คุณสามารถอินเทอร์เฟซเหล่านั้นจากภาษาใด ๆ ที่คุณควรพิจารณา

ตัวแก้เชิงเส้นเบาบาง

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

ประสิทธิภาพและความยืดหยุ่นในการจัดเก็บข้อมูลขนาดใหญ่

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

เกี่ยวกับประสิทธิภาพการทำงานของโหนดถ้าคุณกำลังเขียนรูทีนเชิงตัวเลขด้วยตัวเองมันเป็นวิธีที่ง่ายที่สุดในการรับประสิทธิภาพที่ดีใน Fortran หากคุณมีประสบการณ์เล็กน้อยใน C, C ++ หรือ Python คุณสามารถรับประสิทธิภาพที่เทียบเคียงได้ (C และ C ++ นั้นตายไปแล้วแม้กับ Fortran, Python และ MATLAB จะใช้เวลาประมาณ 25% โดยไม่ต้องใช้ความพยายามมาก) MATLAB ทำสิ่งนี้ผ่านคอมไพเลอร์ JIT และนิพจน์เชิงพีชคณิตเชิงเส้นที่ดีมาก คุณอาจจะต้องใช้ Cython, numpy, numexpr หรือฝังเมล็ดตัวเลขเพื่อรับประสิทธิภาพที่อ้างจาก Python ฉันไม่สามารถแสดงความคิดเห็นเกี่ยวกับประสิทธิภาพของ Java เพราะฉันไม่รู้ภาษาดีนัก แต่ฉันคิดว่ามันไม่ไกลจาก Python ถ้าเขียนโดยผู้เชี่ยวชาญ

หมายเหตุเกี่ยวกับอินเตอร์เฟส

ฉันหวังว่าฉันจะเชื่อมั่นว่าคุณจะสามารถทำทุกสิ่งที่คุณต้องการในภาษาการเขียนโปรแกรมที่คุณกำลังพิจารณา หากคุณกำลังใช้ Java อินเตอร์เฟส C จะมีความท้าทายเล็กน้อย Python มีการรองรับอินเตอร์เฟส C และ Fortran ที่ยอดเยี่ยมผ่าน ctypes, Cython และ f2py LAPACK ได้รับการห่อแล้วและมีให้ผ่าน scipy MATLAB มีฟังก์ชั่นทั้งหมดที่คุณต้องการในไลบรารี่เนทีฟ แต่ไม่สามารถปรับขนาดได้หรือง่ายต่อการทำงานบนคลัสเตอร์ Java สามารถรองรับอินเตอร์เฟส C และ Fortran ด้วยJNIแต่ไม่พบในคลัสเตอร์และซอฟต์แวร์แบบขนานสำหรับการคำนวณทางวิทยาศาสตร์

การบำรุงรักษา

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

คำแนะนำ

ฉันเองโชคดีมากกับงูหลามและฉันขอแนะนำสำหรับโครงการการคำนวณมากมาย ฉันคิดว่าคุณควรพิจารณาอย่างยิ่งสำหรับโครงการของคุณ Python และ MATLAB น่าจะเป็นภาษาที่แสดงออกมากที่สุดสำหรับการคำนวณทางวิทยาศาสตร์ คุณสามารถอินเทอร์เฟซ Python กับภาษาการเขียนโปรแกรมอื่น ๆ ได้อย่างง่ายดายคุณสามารถใช้ f2py เพื่อตัดการใช้งาน Fortran ในปัจจุบันของคุณและเขียนทีละชิ้นทีละชิ้นตามที่คุณต้องการใน Python ในขณะที่ตรวจสอบว่าคุณยังคงใช้งานได้ ในเวลานี้ผมจะแนะนำให้รวมกันของอย่างเป็นทางการหลาม 2.7 การดำเนินการกับSciPy คุณสามารถเริ่มต้นได้อย่างง่ายดายมากกับสแต็คนี้จากที่มีอยู่ได้อย่างอิสระจัดจำหน่าย Enthought หลาม

คุณสามารถทำสิ่งนี้ได้ใน C, C ++ หรือ Fortran C และ C ++ เป็นภาษาที่ดึงดูดใจมากสำหรับนักพัฒนามืออาชีพที่มีประสบการณ์มากมาย แต่บ่อยครั้งที่จะเดินทางไปหานักพัฒนาใหม่และในแง่นี้อาจไม่ใช่ความคิดที่ดีสำหรับรหัสทางวิชาการที่มากขึ้น Fortran และ MATLAB ได้รับความนิยมในการคำนวณเชิงวิชาการ แต่มีความอ่อนแอในโครงสร้างข้อมูลขั้นสูงและการแสดงออกที่ Python เสนอ (คิดว่าเป็นออบเจ็กต์ Python dict)

คำถามที่เกี่ยวข้อง:

• คำแนะนำสำหรับห้องสมุด Java matrix ที่ใช้งานได้รวดเร็ว

นอกจากคำตอบที่ครอบคลุมมากของ Aron ฉันจะดูหัวข้อต่าง ๆ ใน scicomp.stackexchange ที่จัดการกับคำถามที่ภาษาการเขียนโปรแกรมใช้ - ทั้งเกี่ยวกับความเร็วของโปรแกรมเช่นเดียวกับคำถามว่าง่ายหรือยากเพียงใด มันคือการเขียนและบำรุงรักษาซอฟต์แวร์ในภาษาเหล่านี้

ที่กล่าวว่านอกเหนือไปจากสิ่งที่เขียนไว้ที่นั่นให้ฉันทำข้อสังเกตไม่กี่:

(i) คุณรวม Fortran ร่วมในรายการของคุณ สำหรับความรู้ของฉันจำนวนคอมไพเลอร์ที่สนับสนุนจริงมีน้อยมากและอันที่จริงฉันมีค่าเป็นศูนย์ คอมไพเลอร์ Fortran ที่มีอยู่อย่างกว้างขวางที่สุดคือ GNU gfortran และในขณะที่แหล่งพัฒนาปัจจุบันแยกเซ็ตย่อยของอาร์เรย์ร่วมฉันเชื่อว่ามันไม่รองรับจริง ๆ (เช่นมันยอมรับไวยากรณ์ แต่ไม่ใช้ความหมาย) . นี่เป็นข้อสังเกตโดยทั่วไปเกี่ยวกับมาตรฐาน Fortran ที่ใหม่กว่า: ความล่าช้าที่คอมไพเลอร์สนับสนุนมาตรฐานใหม่นั้นถูกวัดในหลายปีที่ผ่านมาคอมไพเลอร์ได้ใช้ Fortran 2003 ในช่วงสองสามปีที่ผ่านมาและสนับสนุน Fortran 2008 เพียงบางส่วนเท่านั้น สิ่งนี้ไม่ควรหยุดคุณจากการใช้งานใด ๆ หากคุณมีคอมไพเลอร์ที่เกิดขึ้นเพื่อสนับสนุนสิ่งที่คุณใช้

(ii) สิ่งนี้เป็นจริงอย่างแน่นอนกับ C ++ / Cilk +: ใช่ Intel กำลังพัฒนาสิ่งนี้ในสาขาของ GCC แต่ไม่สามารถใช้ได้ในการเผยแพร่ GCC ใด ๆ และอาจเป็นไปได้ไม่นาน คุณสามารถคาดหวังได้ว่าจะใช้เวลาอีก 2-3 ปีอย่างน้อยจนกว่าคุณจะพบ Cilk + พร้อมกับรุ่น GCC ที่ติดตั้งบนเครื่อง Linux ทั่วไป

(iii) C ++ / TBB เป็นเรื่องที่แตกต่าง: TBB อยู่มานานแล้วมีอินเทอร์เฟซที่เสถียรมากและสามารถคอมไพล์ได้กับคอมไพเลอร์ C ++ ส่วนใหญ่ที่มีอยู่ในช่วงหลายปีที่ผ่านมา (บน linux เช่นเดียวกับบน Windows) . เราได้ใช้มันในการจัดการ IIเป็นเวลาหลายปีแล้วด้วยผลลัพธ์ที่ดี นอกจากนี้ยังมีหนังสือที่ดีมาก

(iv) ฉันมีความคิดเห็นของตัวเองเกี่ยวกับ OpenMP กล่าวคือมันเป็นทางออกในการค้นหาปัญหา มันทำงานได้ดีสำหรับการขนานลูปภายในซึ่งเป็นสิ่งที่น่าสนใจหากคุณมีโครงสร้างข้อมูลปกติมาก แต่มันไม่ค่อยเป็นสิ่งที่คุณต้องการทำถ้าคุณต้องการทำขนานอะไรบางอย่าง - เพราะสิ่งที่คุณต้องการจะทำคือการขนานลูปนอก และสำหรับสิ่งนั้นการแก้ปัญหาเช่น TBB เป็นวิธีแก้ปัญหาที่ดีกว่ามากเพราะใช้กลไกของภาษาการเขียนโปรแกรมแทนที่จะพยายามอธิบายสิ่งที่เกิดขึ้นนอกภาษา (ผ่าน #pragmas) และในลักษณะที่คุณไม่สามารถเข้าถึงตัวจัดการเธรด ตัวบ่งชี้สถานะผลลัพธ์ ฯลฯ จากภายในโปรแกรมของคุณ

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

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

อย่างไรก็ตามโดยเฉพาะอย่างยิ่งเกี่ยวกับความเท่าเทียมฉันขอแนะนำให้คุณลองคิดนอกกรอบ OpenMP มีจุดแข็ง แต่ติดอยู่ในความคิดของการใช้รหัสตามลำดับและการสแลปขนานกันที่นี่และตรงนั้น ในทำนองเดียวกันสำหรับ Intels TBB

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

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

มีการพูดคุยกันเล็กน้อยเกี่ยวกับ coarray fortran ในความคิดเห็นข้างต้น ในเวลานี้และสำหรับความรู้ที่ จำกัด ของฉันการสนับสนุน coarray ในคอมไพเลอร์มีดังนี้:

• Cray มีคอมไพเลอร์ซึ่งรองรับคุณสมบัติของ coarray พื้นฐานเป็นอย่างน้อย ฉันเคยใช้มันเพื่อเขียนโค้ดที่ตั้งใจให้เป็น "ทางการศึกษา" แต่ฉันบอกว่าคุณสามารถเขียนโค้ดจริงใน coarray fortran ไวยากรณ์และแนวคิดส่วนใหญ่ง่ายกว่า MPI แต่เช่นเคยมีกับดักจำนวนมากและกับกับดักนั้นแตกต่างจาก MPI
• Intel fortran มีการสนับสนุน coarray ที่สร้างขึ้นจากห้องสมุด MPI ของพวกเขา สมมุติว่านี่เป็นการ จำกัด ประสิทธิภาพสูงสุดทางทฤษฎี แต่ฉันไม่ได้เห็นการวัด
• Gfortran รองรับ coarrays แต่สำหรับภาพเดียว (หรืออันดับเดียวใน MPI พูด) ดังนั้นจึงไม่มีการขนานที่แท้จริงจนกว่า gfortran 4.8 หรือ 4.9 จะออกมา

โดยทั่วไปฉันจะระมัดระวังถ้าเริ่มต้นรหัสที่ใช้ Coarray ไวยากรณ์นั้นง่ายและสะดวกกว่า Fortran / C / C ++ ด้วย MPI แต่ก็ไม่ได้มีคุณลักษณะครบถ้วน ตัวอย่างเช่น MPI สนับสนุนการดำเนินการลดจำนวนมากฯลฯ ซึ่งอาจสะดวกสำหรับคุณมาก มันขึ้นอยู่กับความต้องการของคุณสำหรับการสื่อสารมากมาย หากคุณต้องการตัวอย่างแจ้งให้เราทราบและฉันสามารถให้คุณไม่กี่ถ้าฉันสามารถขุดไฟล์

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

การถดถอยโลจิสติก (สกาล่า):

//load data to distributed memory
val points = spark.textFile(...).map(parsePoint).cache()
var w = Vector.random(D) // current separating plane
for (i <- 1 to ITERATIONS) {
  val gradient = points.map(p =>
    (1 / (1 + exp(-p.y*(w dot p.x))) - 1) * p.y * p.x
  ).reduce(_ + _)
  w -= gradient
}
println("Final separating plane: " + w)

มีส่วนขยายที่เรียกว่าMLib (ไลบรารีการเรียนรู้ของเครื่อง) ซึ่งใช้ไลบรารี Fortran สำหรับการคำนวณระดับต่ำ (สำหรับ Python ฉันเดาว่าใช้หมายเลข) ดังนั้นแนวคิดนั้นง่าย ๆ จดจ่อกับอัลกอริธึมของคุณและทำให้การปรับให้เหมาะสมอยู่ในระดับที่ต่ำกว่า (ลำดับของการประมวลผลการกระจายข้อมูล ฯลฯ )