The advent of large multi-core syst

The advent of large multi-core systems has renewed interest in programming models that simplify parallel programming. Recursive parallel programming models, as exemplified by Cilk [4], put forth a simple concurrency model. A
programmer divides the given work into smaller work units
whose results are recursively combined to provide the final
result. This divide-and-conquer strategy simplifies programmer’s effort to specifying concurrency. Often, a concurrencyannotated version of a sequential recursive program (a principle referred to as “serial elision” in Cilk).
However, this divide-and-conquer strategy can impose additional constraints on concurrency in the program. SpecifACM acknowledges that this contribution was authored or co-authored by an employee, or contractor of the national government. As such, the Government retains
a nonexclusive, royalty-free right to publish or reproduce this article, or to allow others to do so, for Government purposes only. Permission to make digital or hard copies
for personal or classroom use is granted. Copies must bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than
ACM must be honored. To copy otherwise, distribute, republish, or post, requires prior
specific permission and/or a fee. Request permissions from [e-mail].
SC ’15, November 15-20, 2015, Austin, TX, USA
c 2015 ACM. ISBN 978-1-4503-3723-6/15/11. . . $15.00
DOI: http://dx.doi.org/10.1145/2807591.2807597
ically, all work represented by two work units are ordered if
any operation in one unit depends on any operation in the
other. In general, Cilk-like programming models represent
the computation as a series-parallel directed acyclic graph
(dag). Computations whose dependence structure is modeled by a more general dag need to be embedded into an
SP-dag by introducing additional edges. This can significantly limit available parallelism and thus scalability.
In this paper, we try to answer the question: is it possible
to achieve the best performance for arbitrary computation
dags while retaining Cilk’s simplicity? We present an approach to speculatively recover the concurrency lost due to
a recursive parallel program specification. We exploit several
characteristics of the structured expression of concurrency in
Cilk programs. In many Cilk computations, the dag structure is independent of the problem size, enabling us to capture data-independent concurrency constraints efficiently1.
Unlike speculation for loop programs, relaxing such concurrency constraints in Cilk exposes significant additional
work and concurrency therein, which, in turn, greatly increases the benefits achievable from optimistic parallelization. Finally, scalable Cilk programs employ coarse-grained
base cases that can be efficiently annotated to track data
accesses and detect conflicts.
We design a runtime system that enables speculative execution of Cilk programs. We present schemes that employ
increasing degrees of speculation to explore additional opportunities for relaxing concurrency constraints. These include single-task, multi-task (a.k.a. deep), and parallel speculation. We develop a predictor to efficiently and accurately
identify opportunities for speculation while considerably reducing the number of mis-speculations. We design a userlevel API to annotate Cilk programs and achieve efficient
data versioning and conflict detection under speculation.
We evaluate the various schemes and demonstrate that
speculation can significantly reduce idle times induced by
concurrency constraints and improve upon original Cilk programs. We demonstrate that the speculation framework incurs low space and time overheads. In addition, we show
that speculation incurs low overheads in the absence of profitable speculation opportunities. Evaluation of the speculation predictor shows it can precisely identify speculation
opportunities and keep mis-speculations low.
The primary contributions of the paper are:
• A speculation approach to overcome concurrency constraints in recursive parallel programs

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

การถือกำเนิดของระบบมัลติคอร์ขนาดใหญ่ได้ต่อสัญญาสนใจในการเขียนโปรแกรมรูปแบบที่ทำให้การเขียนโปรแกรมแบบขนาน ซ้ำแบบขนานรุ่น การเขียนโปรแกรมเป็นแบบอย่าง โดยซิลก์ ซีสตาร์ [4], ใส่ไว้แบบง่าย ๆ กัน Aโปรแกรมเมอร์แบ่งการทำงานให้เป็นหน่วยงานขนาดเล็กมีผลลัพธ์คือ recursively รวมเพื่อให้สุดท้ายผลการค้นหา กลยุทธ์นี้แบ่ง และพิชิตช่วยโปรแกรมเมอร์พยายามระบุเกิดพร้อมกัน มักจะ concurrencyannotated รุ่นของโปรแกรมตามลำดับซ้ำ (หลักการที่เรียกว่า "อนุกรม elision" ในซิลก์ ซีสตาร์)อย่างไรก็ตาม กลยุทธ์นี้แบ่ง และพิชิตสามารถกำหนดข้อจำกัดเพิ่มเติมพร้อมกันในโปรแกรม SpecifACM รับทราบว่า เงินส่วนนี้ถูกเขียน หรือเขียนร่วมพนักงาน หรือผู้รับเหมาของรัฐบาล เช่นนี้ รัฐบาลยังคงไม่เฉพาะเจาะจง เสียสิทธิเผยแพร่ หรือทำซ้ำบทความนี้ หรือ การให้ผู้อื่นทำ รัฐบาลเท่านั้น การทำดิจิตอลหรือฉบับสำหรับใช้ส่วนตัวหรือห้องเรียนได้รับ สำเนาต้องหมีตัวนี้และการอ้างอิงเต็มบนหน้าแรก สำหรับส่วนประกอบของงานนี้มากกว่าผู้อื่นเป็นเจ้าของลิขสิทธิ์ACM ต้องสามารถใช้ได้ เพื่อคัดลอกมิฉะนั้น กระจาย ประกาศใหม่ หรือโพสต์ กำหนดล่วงหน้าสิทธิ์เฉพาะและ/หรือค่าธรรมเนียม ร้องขอสิทธิ์จาก [e-mail] ' 15, 15-20, 2558, Austin, TX สหรัฐอเมริกาACM c ใน 2015 ISBN 978-1-4503-3723-6/15/11 . . $15.00ดอย: http://dx.doi.org/10.1145/2807591.2807597ically มีสั่งงานทั้งหมดที่แสดง โดยสองหน่วยงานถ้าการดำเนินการใด ๆ ในหนึ่งหน่วยตามการดำเนินการใด ๆ ในการอื่น ๆ ทั่วไป ซิลก์ ซีสตาร์เหมือนเขียนโปรแกรมรุ่นแทนการคำนวณเป็นชุดคู่ขนานนำ acyclic graph(dag) ประมวลผลใหม่ที่มีโครงสร้างพึ่งพา โดยการ dag ทั่วไปจำเป็นต้องฝังเข้าไปในตัวSP-dag โดยการแนะนำเพิ่มเติมขอบ นี้อย่างมากสามารถจำกัดขนานพร้อมใช้งาน และ scalabilityในกระดาษนี้ เราพยายามตอบคำถาม: เป็นไปได้เพื่อให้เกิดประสิทธิภาพที่ดีที่สุดสำหรับการคำนวณโดยพลการdags ยังคงความเรียบง่ายของซิลก์ ซีสตาร์ เรานำเสนอวิธีการเกี่ยวกับการพิจารณาเงินกู้คืนครบกำหนดไปพร้อมกันข้อมูลจำเพาะขนานโปรแกรมซ้ำ เราใช้ประโยชน์จากหลายลักษณะของนิพจน์ที่มีโครงสร้างการเกิดพร้อมกันในโปรแกรมซิลก์ ซีสตาร์ ในการประมวลผลหลายในซิลก์ ซีสตาร์ โครงสร้าง dag เป็นอิสระจากปัญหาขนาด ทำให้เราสามารถจับข้อมูลอิสระกันข้อจำกัด efficiently1ซึ่งแตกต่างจากการเก็งกำไรสำหรับโปรแกรมวนรอบ ผ่อนคลายข้อจำกัดดังกล่าวพร้อมกันในซิลก์ ซีสตาร์ exposes สำคัญเพิ่มเติมทำงานและพร้อมกันนั้น ซึ่ง ในทางกลับกัน ช่วยเพิ่มผลประโยชน์ทำได้จาก parallelization ในเชิงบวก ในที่สุด โปรแกรมซิลก์ ซีสตาร์ขนาดจ้างเนื้อหยาบกรณีพื้นฐานที่สามารถ annotated ประสิทธิภาพการติดตามข้อมูลเข้าถึง และตรวจหาความขัดแย้งเราออกแบบระบบรันไทม์ซึ่งช่วยให้การดำเนินการเก็งกำไรของโปรแกรมซิลก์ ซีสตาร์ เรานำเสนอรูปแบบการจ้างงานเพิ่มองศาของการเก็งกำไรโอกาสเพิ่มเติมสำหรับข้อจำกัดกันผ่อนคลาย เหล่านี้รวมถึง งานเดี่ยว หลายงาน (หรือลึก), และการเก็งกำไรแบบขนาน เราพัฒนาทำนายไปอย่างมีประสิทธิภาพ และถูกต้องระบุโอกาสสำหรับการเก็งกำไรในขณะที่ลดจำนวน speculations ผิด เราออกแบบ userlevel API เพื่ออธิบายโปรแกรมซิลก์ ซีสตาร์ และบรรลุอย่างมีประสิทธิภาพข้อมูลการกำหนดรุ่นและความขัดแย้งการตรวจจับภายใต้การเก็งกำไรเราประเมินแผนงานต่าง ๆ และแสดงให้เห็นว่าการเก็งกำไรสามารถลดเวลาว่างที่เกิดจากข้อจำกัดการเกิดพร้อมกัน และปรับปรุงโปรแกรมซิลก์ ซีสตาร์ เราแสดงให้เห็นว่า กรอบการเก็งกำไรเกิดขึ้นพื้นที่ต่ำและเสียเวลา นอกจากนี้ เราแสดงการเก็งกำไรที่ incurs ค่าโสหุ้ยต่ำขาดโอกาสในการเก็งกำไร การประเมินผลของ predictor เก็งกำไรแสดงมันสามารถระบุเก็งกำไรได้อย่างแม่นยำโอกาสและ speculations ผิดให้ต่ำผลงานหลักของกระดาษคือ:•วิธีการเก็งกำไรเพื่อเอาชนะข้อจำกัดเกิดพร้อมกันในโปรแกรมขนานซ้ำ

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

การกำเนิดของระบบแบบ multi-core ขนาดใหญ่มีความสนใจในรูปแบบการเขียนโปรแกรมที่ง่ายเขียนโปรแกรมแบบขนาน ซ้ำรูปแบบการเขียนโปรแกรมแบบขนานอย่างสุดขั้ว Cilk [4], นำออกมาเป็นรูปแบบที่เรียบง่ายเห็นพ้องด้วย
โปรแกรมเมอร์แบ่งการทำงานให้เป็นหน่วยงานขนาดเล็ก
ที่มีผลจะรวมกันเพื่อให้ซ้ำสุดท้าย
ผล กลยุทธ์การแบ่งและพิชิตนี้ง่ายความพยายามของโปรแกรมเมอร์การระบุเห็นพ้องด้วย มักจะเป็นรุ่น concurrencyannotated โปรแกรม recursive ลำดับ (หลักการที่เรียกว่า "ตัดออกอนุกรม" ใน Cilk).
อย่างไรก็ตามกลยุทธ์การแบ่งและพิชิตนี้สามารถกำหนดข้อ จำกัด เพิ่มเติมเกี่ยวกับการเห็นพ้องด้วยในโปรแกรม SpecifACM ยอมรับว่าผลงานนี้ได้รับการประพันธ์หรือร่วมประพันธ์โดยพนักงานหรือผู้รับเหมาของรัฐบาลแห่งชาติ เป็นเช่นนี้รัฐบาลยังคง
เจาะจงขวาค่าภาคหลวงฟรีที่จะเผยแพร่หรือทำซ้ำบทความนี้หรืออนุญาตให้ผู้อื่นให้ทำเช่นนั้นเพื่อวัตถุประสงค์ในรัฐบาลเท่านั้น ได้รับอนุญาตให้ทำสำเนาดิจิตอลหรือยาก
สำหรับการใช้งานส่วนบุคคลหรือในชั้นเรียนจะได้รับ สำเนาต้องแบกแจ้งให้ทราบล่วงหน้านี้และการอ้างอิงเต็มรูปแบบบนหน้าแรก ลิขสิทธิ์สำหรับส่วนประกอบของงานนี้เป็นของผู้อื่นมากกว่า
ACM ต้องได้รับเกียรติ มิฉะนั้นการคัดลอกแจกจ่ายเผยแพร่หรือโพสต์ต้องก่อน
ได้รับอนุญาตที่เฉพาะเจาะจงและ / หรือค่าธรรมเนียม สิทธิ์การร้องขอจาก [e-mail].
SC '15, 15-20 พฤศจิกายน 2015 ออสติน, TX, USA
C 2015 พลอากาศเอก ISBN 978-1-4503-3723-6 / 15/11 . . $ 15.00
ดอย: http://dx.doi.org/10.1145/2807591.2807597
ically งานทั้งหมดแสดงโดยทั้งสองหน่วยงานจะได้รับคำสั่งหาก
ดำเนินการใด ๆ ในหนึ่งหน่วยขึ้นอยู่กับการดำเนินการใด ๆ ใน
อื่น ๆ โดยทั่วไป Cilk เหมือนแบบจำลองการเขียนโปรแกรมแทน
การคำนวณเป็นวัฏจักรกราฟชุดขนานกำกับ
(ลูกไม้) การคำนวณที่มีโครงสร้างการพึ่งพาอาศัยกันเป็นแบบจำลองโดย dag ทั่วไปมากขึ้นจะต้องมีการฝังตัวเข้าไปใน
SP-dag โดยการแนะนำขอบเพิ่มเติม นี้อย่างมีนัยสำคัญสามารถ จำกัด ขนานที่มีอยู่และทำให้ scalability.
ในบทความนี้เราพยายามที่จะตอบคำถาม: มันเป็นไปได้
เพื่อให้เกิดประสิทธิภาพที่ดีที่สุดในการคำนวณโดยพล
DABs ความขณะที่การรักษาความเรียบง่าย Cilk หรือไม่? เรานำเสนอวิธีการในการกู้คืนการพิจารณาพร้อมกันหายไปเนื่องจาก
ข้อกำหนดโปรแกรม recursive ขนาน เราใช้ประโยชน์จากหลาย
ลักษณะของการแสดงออกที่มีโครงสร้างของการทำงานพร้อมกันใน
โปรแกรม Cilk ในการคำนวณ Cilk หลายโครงสร้าง dag มีความเป็นอิสระที่มีขนาดปัญหาที่ทำให้เราสามารถเก็บข้อมูลที่เป็นอิสระ จำกัด เห็นพ้อง efficiently1.
ซึ่งแตกต่างจากการเก็งกำไรสำหรับโปรแกรมห่วงผ่อนคลายข้อ จำกัด การทำงานพร้อมกันดังกล่าวใน Cilk exposes เพิ่มเติมอย่างมีนัยสำคัญ
ในการทำงานและการทำงานพร้อมกันในนั้นซึ่งในการเปิด ช่วยเพิ่มผลประโยชน์ที่ประสบความสำเร็จจากการทำคู่ขนานในแง่ดี สุดท้ายโปรแกรม Cilk ปรับขนาดได้จ้างเนื้อหยาบ
กรณีฐานที่สามารถบันทึกย่อได้อย่างมีประสิทธิภาพเพื่อติดตามข้อมูลการ
เข้าถึงและตรวจสอบความขัดแย้ง.
เราออกแบบระบบรันไทม์ที่ช่วยให้การดำเนินการเก็งกำไรของโปรแกรม Cilk เรานำเสนอรูปแบบที่จ้าง
องศาที่เพิ่มขึ้นของการเก็งกำไรในการสำรวจโอกาสเพิ่มเติมสำหรับการผ่อนคลายข้อ จำกัด การทำงานพร้อมกัน เหล่านี้รวมถึงงานเดี่ยวหลายงาน (aka ลึก) และการเก็งกำไรขนาน เราพัฒนาทำนายได้อย่างมีประสิทธิภาพและอย่างถูกต้อง
ระบุโอกาสสำหรับการเก็งกำไรในขณะที่การลดจำนวนมากของการผิดพลาดคาดเดา เราออกแบบ userlevel API เพื่อใส่คำอธิบายประกอบโปรแกรม Cilk ที่มีประสิทธิภาพและบรรลุ
เวอร์ชันข้อมูลและการตรวจสอบความขัดแย้งภายใต้การเก็งกำไร.
เราจะประเมินรูปแบบต่างๆและแสดงให้เห็นว่า
การเก็งกำไรอย่างมีนัยสำคัญสามารถลดเวลาในการใช้งานที่เกิดจาก
ข้อ จำกัด ของการทำงานพร้อมกันและปรับปรุงโปรแกรม Cilk เดิม เราแสดงให้เห็นว่ากรอบการเก็งกำไรเกิดขึ้นจากพื้นที่ต่ำและค่าโสหุ้ยในเวลา นอกจากนี้เราแสดงให้เห็น
ว่าการเก็งกำไรเกิดขึ้นจากค่าใช้จ่ายที่ต่ำในกรณีที่ไม่มีโอกาสเก็งกำไรผลกำไร การประเมินผลการทำนายการเก็งกำไรแสดงให้เห็นว่าสามารถระบุได้อย่างแม่นยำเก็งกำไร
โอกาสและให้การคาดเดาผิดพลาดต่ำ.
ผลงานหลักของกระดาษที่มี:
•วิธีการเก็งกำไรที่จะเอาชนะข้อ จำกัด การทำงานพร้อมกันในโปรแกรมขนาน recursive

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

การเข้ามาของระบบมัลติคอร์ขนาดใหญ่มีการต่ออายุความสนใจในโปรแกรมรุ่นที่ลดความซับซ้อนของการเขียนโปรแกรมแบบขนาน ผู้เขียนโปรแกรมแบบขนานแบบสุดขั้วโดย cilk [ 4 ] , ยื่นแบบการวิ เป็นโปรแกรมเมอร์แบ่งให้ทำงานในหน่วยงานขนาดเล็กที่มีผลเป็น recursively รวมกันเพื่อให้สุดท้ายผลที่ได้ แบ่งและพิชิตกลยุทธ์ช่วยให้โปรแกรมเมอร์ของความพยายามที่จะระบุการเห็นพ้องด้วย มักจะเป็น concurrencyannotated เวอร์ชั่นของโปรแกรมแบบ recursive ( หลักการเรียกว่า " อนุกรมการตัดออก " ใน cilk )อย่างไรก็ตาม การแบ่งกลุ่มนี้และชนะกลยุทธ์สามารถกำหนดข้อจำกัดในการเพิ่มในโปรแกรม specifacm ยอมรับว่าผลงานนี้ถูกประพันธ์หรือร่วมประพันธ์โดย พนักงานหรือผู้รับเหมาของรัฐบาลแห่งชาติ เช่น รัฐบาลรักษาการเป็น nonexclusive , ค่าภาคหลวงฟรีขวาเพื่อเผยแพร่ หรือทำซ้ำบทความนี้ หรือให้ผู้อื่นทำเพื่อวัตถุประสงค์ของรัฐบาลเท่านั้น อนุญาตให้สำเนาดิจิตอลหรือยากสำหรับใช้ส่วนบุคคลหรือห้องเรียนได้รับ สำเนาจะต้องทนเห็นนี้และการเต็มรูปแบบในหน้าแรก ลิขสิทธิ์สำหรับส่วนประกอบของงานนี้ เป็นของคนอื่นมากกว่าโดยต้องได้รับเกียรติ เพื่อคัดลอกหรือแจกจ่าย เผยแพร่ หรือใช้ก่อนโพสต์อนุญาตเฉพาะเจาะจง และ / หรือ ค่าธรรมเนียม ขอ อนุญาต จาก [e-mail] .D " 15 พฤศจิกายน 15 , 2015 , TX Austin , สหรัฐอเมริกาซี 2015 ACM . ISBN 978-1-4503-3723-6 / 15 / 11 . . . . . . . $ 15.00ดอย : http://dx.doi.org/10.1145/2807591.2807597ically ทั้งหมดทำงานแสดงโดยสองหน่วยงานจะสั่งถ้าการผ่าตัดในหนึ่งหน่วยขึ้นอยู่กับการผ่าตัดในอื่น ๆ โดยทั่วไป cilk ชอบรูปแบบโปรแกรมแทนการคำนวณเป็นชุดคู่ขนานกราฟอวัฏจักรระบุทิศทาง( ลูกไม้ ) วิธีการที่มีโครงสร้างการพึ่งพาแบบโดยวันที่ทั่วไปต้องฝังตัวเป็นSP วันที่โดยการแนะนำขอบเพิ่มเติม นี้สามารถอย่างมีนัยสำคัญของความขนาน และดังนั้นจึง จำกัด กล่าวในกระดาษนี้เราพยายามที่จะตอบคำถาม : เป็นไปได้เพื่อให้บรรลุประสิทธิภาพที่ดีที่สุดสำหรับการคำนวณโดยพลการเดคากรัมในขณะที่การรักษาความเรียบง่าย cilk ? เราเสนอวิธีการกู้คืนสูญหายเนื่องจากการเดาขนานโปรแกรมเป็นผู้กำหนด เราใช้ประโยชน์จากหลาย ๆลักษณะของการแสดงออกของการเห็นพ้องด้วยในโครงสร้างโปรแกรม cilk . ในการคำนวณ cilk หลายโครงสร้างในวันนี้เป็นอิสระของขนาดของปัญหา ให้เราสามารถจับข้อมูลอิสระข้อจำกัดการ efficiently1 .ซึ่งแตกต่างจากการเก็งกำไรสำหรับโปรแกรมลูป ผ่อนคลายข้อจำกัดในการดังกล่าว cilk exposes พบเพิ่มเติมทำงาน และพร้อมกันนั้น ซึ่ง จะช่วยเพิ่มประโยชน์ที่ได้จากมองในแง่ดี parallelization ไป . สุดท้าย โปรแกรม cilk ขนาดจ้างที่มีเนื้อหยาบกรณีฐานที่สามารถมีประสิทธิภาพบันทึกย่อเพื่อติดตามข้อมูลการเข้าถึงและตรวจสอบความขัดแย้งเราออกแบบรันไทม์ระบบที่ช่วยให้การเก็งของโปรแกรม cilk . เรานำเสนอโครงร่างที่จ้างเพิ่มองศาของการเก็งกำไรจะหาโอกาสเพิ่มเติมสำหรับผ่อนคลายข้อจำกัดการเห็นพ้องด้วย เหล่านี้รวมถึงงานเดี่ยวหลายงาน ( หรือลึก ) และการเก็งกำไรแบบขนาน เราพัฒนา ) ได้อย่างมีประสิทธิภาพและถูกต้องระบุโอกาสสำหรับการเก็งกำไร ขณะที่มากลดจำนวนและความ . เราออกแบบ USERLEVEL API เพื่ออธิบายโปรแกรม cilk และบรรลุประสิทธิภาพข้อมูลรุ่นและความขัดแย้งการตรวจสอบภายใต้การคาดการณ์เราประเมินโครงการต่าง ๆ และแสดงให้เห็นว่าการเก็งกำไรสามารถลดความเกียจคร้านครั้งข้อจำกัดและการปรับปรุงโปรแกรม cilk ต้นฉบับ เราแสดงให้เห็นว่าการเก็งกำไรในกรอบพื้นที่และเวลากำลังต่ำ overheads นอกจากนี้ เราแสดงที่การเกิดต่ำ overheads ขาดโอกาสในการทำกำไร การประเมินผลของการทำนายได้แน่นอน ระบุ การแสดงโอกาสและให้ความผิดพลาดน้อยผลงานหลักของกระดาษมีดังนี้- เป็นวิธีการที่จะเอาชนะอุปสรรคในการเก็งผลโปรแกรมขนาน