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. Specifically, 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.

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

การถือกำเนิดของระบบมัลติคอร์ขนาดใหญ่ได้ต่อสัญญาสนใจในการเขียนโปรแกรมรูปแบบที่ทำให้การเขียนโปรแกรมแบบขนาน ซ้ำแบบขนานรุ่น การเขียนโปรแกรมเป็นแบบอย่าง โดยซิลก์ ซีสตาร์ [4], ใส่ไว้แบบง่าย ๆ กัน Aโปรแกรมเมอร์แบ่งการทำงานให้เป็นหน่วยงานขนาดเล็กมีผลลัพธ์คือ recursively รวมเพื่อให้สุดท้ายผลการค้นหา กลยุทธ์นี้แบ่ง และพิชิตช่วยโปรแกรมเมอร์พยายามระบุเกิดพร้อมกัน มักจะ concurrencyannotated รุ่นของโปรแกรมตามลำดับซ้ำ (หลักการที่เรียกว่า "อนุกรม elision" ในซิลก์ ซีสตาร์)อย่างไรก็ตาม กลยุทธ์นี้แบ่ง และพิชิตสามารถกำหนดข้อจำกัดเพิ่มเติมพร้อมกันในโปรแกรม เฉพาะ มีสั่งงานทั้งหมดที่แสดง โดยสองหน่วยงานถ้าการดำเนินการใด ๆ ในหนึ่งหน่วยตามการดำเนินการใด ๆ ในการอื่น ๆ ทั่วไป ซิลก์ ซีสตาร์เหมือนเขียนโปรแกรมรุ่นแทนการคำนวณเป็นชุดคู่ขนานนำ 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).
อย่างไรก็ตามกลยุทธ์การแบ่งและพิชิตนี้สามารถกำหนดข้อ จำกัด เพิ่มเติมเกี่ยวกับการเห็นพ้องด้วยในโปรแกรม โดยเฉพาะการทำงานทั้งหมดที่แสดงโดยทั้งสองหน่วยงานจะได้รับคำสั่งหาก
ดำเนินการใด ๆ ในหนึ่งหน่วยขึ้นอยู่กับการดำเนินการใด ๆ ใน
อื่น ๆ โดยทั่วไป Cilk เหมือนแบบจำลองการเขียนโปรแกรมแทน
การคำนวณเป็นวัฏจักรกราฟชุดขนานกำกับ
(ลูกไม้) การคำนวณที่มีโครงสร้างการพึ่งพาอาศัยกันเป็นแบบจำลองโดย dag ทั่วไปมากขึ้นจะต้องมีการฝังตัวเข้าไปใน
SP-dag โดยการแนะนำขอบเพิ่มเติม นี้อย่างมีนัยสำคัญสามารถ จำกัด ขนานที่มีอยู่และทำให้ scalability.
ในบทความนี้เราพยายามที่จะตอบคำถาม: มันเป็นไปได้
เพื่อให้เกิดประสิทธิภาพที่ดีที่สุดในการคำนวณโดยพล
DABs ความขณะที่การรักษาความเรียบง่าย Cilk หรือไม่? เรานำเสนอวิธีการในการกู้คืนการพิจารณาพร้อมกันหายไปเนื่องจาก
ข้อกำหนดโปรแกรม recursive ขนาน เราใช้ประโยชน์จากหลาย
ลักษณะของการแสดงออกที่มีโครงสร้างของการทำงานพร้อมกันใน
โปรแกรม Cilk ในการคำนวณ Cilk หลายโครงสร้าง dag มีความเป็นอิสระที่มีขนาดปัญหาที่ทำให้เราสามารถเก็บข้อมูลที่เป็นอิสระ จำกัด เห็นพ้อง efficiently1.
ซึ่งแตกต่างจากการเก็งกำไรสำหรับโปรแกรมห่วงผ่อนคลายข้อ จำกัด การทำงานพร้อมกันดังกล่าวใน Cilk exposes เพิ่มเติมอย่างมีนัยสำคัญ
ในการทำงานและการทำงานพร้อมกันในนั้นซึ่งในการเปิด ช่วยเพิ่มผลประโยชน์ที่ประสบความสำเร็จจากการทำคู่ขนานในแง่ดี สุดท้ายโปรแกรม Cilk ปรับขนาดได้จ้างเนื้อหยาบ
กรณีฐานที่สามารถบันทึกย่อได้อย่างมีประสิทธิภาพเพื่อติดตามข้อมูลการ
เข้าถึงและตรวจสอบความขัดแย้ง.
เราออกแบบระบบรันไทม์ที่ช่วยให้การดำเนินการเก็งกำไรของโปรแกรม Cilk เรานำเสนอรูปแบบที่จ้าง
องศาที่เพิ่มขึ้นของการเก็งกำไรในการสำรวจโอกาสเพิ่มเติมสำหรับการผ่อนคลายข้อ จำกัด การทำงานพร้อมกัน เหล่านี้รวมถึงงานเดี่ยวหลายงาน (aka ลึก) และการเก็งกำไรขนาน เราพัฒนาทำนายได้อย่างมีประสิทธิภาพและอย่างถูกต้อง
ระบุโอกาสสำหรับการเก็งกำไรในขณะที่การลดจำนวนมากของการผิดพลาดคาดเดา เราออกแบบ userlevel API เพื่อใส่คำอธิบายประกอบโปรแกรม Cilk ที่มีประสิทธิภาพและบรรลุ
เวอร์ชันข้อมูลและการตรวจสอบความขัดแย้งภายใต้การเก็งกำไร.
เราจะประเมินรูปแบบต่างๆและแสดงให้เห็นว่า
การเก็งกำไรอย่างมีนัยสำคัญสามารถลดเวลาในการใช้งานที่เกิดจาก
ข้อ จำกัด ของการทำงานพร้อมกันและปรับปรุงโปรแกรม Cilk เดิม เราแสดงให้เห็นว่ากรอบการเก็งกำไรเกิดขึ้นจากพื้นที่ต่ำและค่าโสหุ้ยในเวลา นอกจากนี้เราแสดงให้เห็น
ว่าการเก็งกำไรเกิดขึ้นจากค่าใช้จ่ายที่ต่ำในกรณีที่ไม่มีโอกาสเก็งกำไรผลกำไร การประเมินผลการทำนายการเก็งกำไรแสดงให้เห็นว่าสามารถระบุได้อย่างแม่นยำเก็งกำไร
โอกาสและให้การคาดเดาผิดพลาดต่ำ