ภาษาการเขียนโปรแกรมที่ทุกฟังก์ชั่นการโทร / บล็อกทำในเธรดแยกกันหรือไม่ [ปิด]

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

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

(ฉันขอโทษถ้านี่เป็นสถานที่ที่ผิดที่จะโพสต์ถ้าเป็นเช่นนั้นฉันยินดีที่จะขอบคุณถ้าคุณชี้ให้ฉันไปยังสถานที่ที่เหมาะสมที่อนุญาตให้มีคำถามเช่นของฉัน)

ทุกฟังก์ชั่นการโทร / บล็อกใหม่ (ถ้าส่วนคำสั่งลูปเป็นต้น) จะทำงานในเธรดแยกต่างหาก

อ่านเพิ่มเติมเกี่ยวกับความต่อเนื่องและสไตล์การส่งต่อ (และความสัมพันธ์กับเธรดหรือ coroutines) ฉันแนะนำให้อ่านSICP & Lisp เป็นชิ้นเล็กๆ นอกจากนี้การเขียนโปรแกรมภาษา Pragmatics ยังให้ภาพรวมที่เป็นประโยชน์ของหลายภาษาและจะช่วยคุณในการออกแบบของคุณเอง

ดังนั้นฉันจึงสงสัยว่าภาษาดังกล่าวจะดูฉลาดได้อย่างไร

ไวยากรณ์ไม่สำคัญมากสำหรับการสำรวจความคิด ความหมายมีความหมายมากขึ้น ฉันแนะนำให้ใช้S-exprเช่นไวยากรณ์ (เพื่อให้คุณสามารถสร้างต้นแบบโดยใช้ Scheme และcall / cc ได้ในตอนแรก

เมื่อความคิดของคุณชัดเจนมากขึ้น (หลังจากการทดลองบางอย่าง) คุณอาจพูดคุยเรื่องนี้กับlambda-the-ultimateคุณสามารถกำหนดไวยากรณ์ที่เซ็กซี่มากขึ้น (ซึ่งจริง ๆ แล้วสำคัญหากคุณต้องการให้ผู้คนนำภาษาของคุณไปใช้ การใช้งานตัวอย่างซอฟแวร์ฟรีเอกสารประกอบห้องสมุดมาตรฐานส่วนต่อประสานฟังก์ชั่นต่างประเทศ ฯลฯ )

คุณอาจจะสนใจในการอ่านเกี่ยวกับการวิจัยลงในข้อมูลแบบขนาน Haskell หากคุณค้นหาใน Youtube ไซม่อนเพย์ตันโจนส์ได้พูดคุยที่น่าสนใจเกี่ยวกับเรื่องนี้ด้วย

ถ้าฉันจำได้อย่างถูกต้องจากคำปราศรัยของเขาในการเขียนโปรแกรมฟังก์ชั่นล้วนๆมันแทบจะเป็นเรื่องเล็กน้อยที่จะหาโอกาสในการสร้างเธรด ปัญหาหลักของเขาในการวิจัยของเขาคือการมีจำนวนมากเกินไปที่สั้นเกินไปเช่นค่าใช้จ่ายในการสร้างหัวข้อและการสื่อสารผลลัพธ์ของพวกเขาเป็นหลักเมื่อเทียบกับประโยชน์ของการขนาน ตัวอย่างเช่นมันง่ายที่จะสอนคอมไพเลอร์ให้หมุน 100 เธรดเพื่อคำนวณsum $ fmap (+1) <100 length vector>แต่ค่าใช้จ่ายจะคุ้มค่าหรือไม่

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

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

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

จะเป็นนามธรรมมากขึ้นcalcul-แคลคูลัสเป็นวิธีการที่สวยงามในการสร้างแบบจำลองการคำนวณแบบขนาน มันยากที่จะทำให้หัวของคุณไปรอบ ๆ เว้นแต่คุณจะได้รับหนังสือระบบการสื่อสารและโทรศัพท์มือถือ: The Pi Calculusโดย Robin Milner มันช่วยให้ฉันคิดถึงการคำนวณแบบขนานในแง่ที่กว้างขึ้นว่า "หลายเธรดเข้าถึงหน่วยความจำที่ใช้ร่วมกัน" มันค่อนข้างน่าสนใจว่าคำสั่งแบบมีเงื่อนไข "gotos" และอื่น ๆ สามารถสร้างขึ้นได้จากแบบดั้งเดิมที่เรียบง่ายและเป็นธรรมชาติขนานกัน

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

เคยพยายามทำโครงการที่คล้ายกันในอดีต ฉันแนะนำให้อ่านคลาสสิกเพื่อขโมยไอเดีย (ลิงก์ทั้งหมดไปที่ Wikipedia)

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

• Occam ภาษานี้ได้รับการออกแบบมาสำหรับการใช้งานจริง ที่นี่มีคำหลัก PAR ซึ่งหมายความว่ารายการคำสั่งควรดำเนินการแบบขนาน

• Erlangอีกภาษาในโลกแห่งความจริง หนึ่งนี้ถูกใช้โดย Ericsson บริษัท โทรคมนาคมและมีค่อนข้างดังต่อไปนี้ พวกเขาได้ทุ่มเทอย่างมากในการทำให้ความเท่าเทียมในทางปฏิบัติและใช้ได้จริง

• Google GOนี่คือพวงของโปรดของฉัน แนวคิดเหมือนกับ Erlang มาก แต่มีไวยากรณ์ที่ดีกว่าและน้ำหนักของ Google อยู่ด้านหลัง มีอะไรผิดปกติไปได้บ้าง

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

เป็นไปได้ แต่จะไม่เป็นประโยชน์สำหรับ 99 +% ของแอปพลิเคชั่นที่คิดได้ทั้งหมด ลอจิกเป็นลำดับที่ถูกผูกไว้โดยทั่วไปมันเป็นกระแส ทีละขั้นตอนคุณไปถึงวิธีการแก้ไขปัญหาและลำดับของขั้นตอนไม่สำคัญเพราะส่วนใหญ่ผลลัพธ์ของขั้นตอนเดียวจะเป็นอินพุตสำหรับถัดไป

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

ดังนั้นฉันคิดว่าเวลาของคุณจะดีกว่าที่จะเรียนรู้วิธีการใช้คุณสมบัติมัลติเธรดในภาษาการเขียนโปรแกรมที่คุณชื่นชอบ

Clojure อาจมีค่าดูความคิดบางอย่าง

http://clojure-doc.org/articles/language/concurrency_and_parallelism.html

นี่คือความคิดบางอย่าง: ถ้าเราเรียกหน่วยการคำนวณที่สามารถดำเนินการได้อย่างอิสระงาน: 1. งานมีความเป็นอิสระเพื่อให้สามารถทำงานพร้อมกันได้ 2. งานที่แตกต่างต้องใช้ทรัพยากรที่แตกต่างกันและใช้เวลาต่างกันในการทำงาน สำหรับปริมาณงานสูงสุด 4. โปรแกรมเดียวในตำแหน่งที่จะทำหน้าที่เป็นตัวกำหนดตารางเวลาเป็นระบบปฏิบัติการ

สิ่งต่าง ๆ เช่นแอปเปิ้ลส่งแกรนด์กลางเป็นความพยายามที่จะให้กำหนดการ

ข้างต้นหมายความว่าความรับผิดชอบในการดำเนินงานไม่จำเป็นต้องเป็นภาษาการเขียนโปรแกรม

ความคิดที่สองคือการลดภาระของการเขียนโปรแกรมระบบขนานให้มากที่สุด วิธีเดียวที่จะทำเช่นนี้คือการลบสเปคของสิ่งที่ต้องทำจากโปรแกรม โปรแกรมควรระบุสิ่งที่ควรทำและที่เหลือควรเกิดขึ้นโดยอัตโนมัติ

ข้างต้นอาจหมายถึงว่าภาษาแบบไดนามิกและการรวบรวมเวลาเป็นวิธีที่จะไป

สิ่งที่คุณกำลังมองหาที่เรียกว่า parallellism นัยและมีภาษาที่มีการสำรวจแนวคิดนี้เช่นดวงอาทิตย์ / ออราเคิลป้อม เหนือสิ่งอื่นใดมัน (อาจ) วิ่งวนไปมาในแนวขนาน

น่าเสียดายที่มันถูกยกเลิกไปแล้วและมีลิงก์จำนวนมากออกมาจากที่นั่น แต่คุณยังสามารถหาไฟล์ PDF บางตัวที่ลอยอยู่รอบ ๆ นั้นได้หากคุณ google แข็งพอ:

https://www.eecis.udel.edu/~cavazos/cisc879-spring2008/papers/fortress.pdf (ข้อมูลจำเพาะภาษา)

http://stephane.ducasse.free.fr/Teaching/CoursAnnecy/0506-Master/ForPresentations/Fortress-PLDITutorialSlides9Jun2006.pdf

http://www.oracle.com/technetwork/systems/ts-5206-159453.pdf

http://dl.acm.org/citation.cfm?id=1122972 (paywalled)

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

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

สิ่งนี้สามารถจำลองได้ค่อนข้างง่ายใน C ++ เพียงให้แน่ใจว่า "ทุกคน" ฟังก์ชั่นการโทร * std::futureจะดำเนินการโดย การจัดการค่าส่งคืนทำได้ง่าย ๆ เพียงโทรหา.get()อนาคต

ดังนั้นคุณอาจสร้างต้นแบบภาษาของคุณโดยการคอมไพล์เป็น C ++ สิ่งนี้จะบอกเราว่าไวยากรณ์จะเป็นอย่างไร: ความแตกต่างหลักคือคุณแยกจุดโทร (ที่มีการป้อนอาร์กิวเมนต์ที่มีให้) จากจุดกลับ (ที่ใช้ฟังก์ชั่นเอาท์พุท)

(*) ฉันพูดว่า "ทุกฟังก์ชั่น" แต่มันก็ขึ้นอยู่กับคุณว่าสิ่งใดนับเป็นฟังก์ชั่น คือmemsetที่แท้จริงหรือฟังก์ชั่นหรือไม่? การกำหนดจำนวนเต็มหรือการกำหนดประเภทที่ผู้ใช้กำหนดเป็นการเรียกใช้ฟังก์ชันหรือไม่