Hare is a new file system that prov

Hare is a new file system that provides a POSIX-like interface
on multicore processors without cache coherence. Hare
allows applications on different cores to share files, directories,
and file descriptors. The challenge in designing Hare
is to support the shared abstractions faithfully enough to run
applications that run on traditional shared-memory operating
systems, with few modifications, and to do so while scaling
with an increasing number of cores.
To achieve this goal, Hare must support features (such as
shared file descriptors) that traditional network file systems
don’t support, as well as implement them in a way that scales
(e.g., shard a directory across servers to allow concurrent
operations in that directory). Hare achieves this goal through
a combination of new protocols (including a 3-phase commit
protocol to implement directory operations correctly and
scalably) and leveraging properties of non-cache-coherent
multiprocessors (e.g., atomic low-latency message delivery
and shared DRAM).
An evaluation on a 40-core machine demonstrates that
Hare can run many challenging Linux applications (including
a mail server and a Linux kernel build) with minimal or
no modifications. The results also show these applications
achieve good scalability on Hare, and that Hare’s techniques
are important to achieving scalability

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

กระต่ายเป็นระบบไฟล์ใหม่ที่มีอินเทอร์เฟซการ POSIX เหมือนบนตัวประมวลผล multicore โดยโปรเจคแค กระต่ายทำให้โปรแกรมประยุกต์บนแกนต่าง ๆ เพื่อแชร์ไฟล์ ไดเรกทอรีและตัวแสดงรายละเอียดแฟ้ม ความท้าทายในการออกแบบกระต่ายคือการ สนับสนุน abstractions ร่วม faithfully พอรันปฏิบัติแบบดั้งเดิมจำใช้ร่วมกันระบบ การปรับเปลี่ยนเพียงเล็กน้อย และทำในขณะที่มาตราส่วนด้วยหมายเลขที่เพิ่มขึ้นของแกนเพื่อให้บรรลุเป้าหมายนี้ กระต่ายต้องสนับสนุนคุณลักษณะ (เช่นใช้ร่วมกันแฟ้มตัวบอก) ที่ระบบแฟ้มเครือข่ายแบบดั้งเดิมไม่สนับสนุน ตลอดจนใช้ในการปรับขนาด(เช่น ชาร์ดไดเรกทอรีบนเซิร์ฟเวอร์ให้พร้อมกันดำเนินการในไดเรกทอรีนั้น) กระต่ายได้รับเป้าหมายนี้ผ่านการรวมกันของโพรโทคอใหม่ (รวมถึงการยอมรับ 3 ขั้นตอนโพรโทคอลการใช้ไดเรกทอรีการดำเนินงานได้อย่างถูกต้อง และscalably) และใช้ประโยชน์จากคุณสมบัติของไม่แคช-coherentนี้ (เช่น อะตอมเวลาแฝงต่ำส่งข้อความก DRAM ที่ใช้ร่วมกัน)การประเมินในเครื่องหลัก 40 แสดงที่กระต่ายสามารถรันหลายท้าทาย Linux โปรแกรมประยุกต์ (รวมถึงเซิร์ฟเวอร์จดหมายและสร้างเคอร์เนล Linux) มีน้อยที่สุด หรือแก้ไขไม่ ผลลัพธ์แสดงโปรแกรมประยุกต์เหล่านี้บรรลุภาระดีกระต่าย และเทคนิคต่าง ๆ ของกระต่ายนั้นมีความสำคัญจะบรรลุภาระ

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

กระต่ายเป็นระบบไฟล์ใหม่ที่มีอินเตอร์เฟซ POSIX
เหมือนบนตัวประมวลผลแบบมัลติคอร์ได้โดยไม่ต้องเชื่อมโยงกันแคช กระต่ายจะช่วยให้การใช้งานบนแกนที่แตกต่างกันในการแบ่งปันไฟล์ไดเรกทอรีและอธิบายไฟล์ ความท้าทายในการออกแบบกระต่ายคือการสนับสนุนแนวคิดที่ใช้ร่วมกันนับถือมากพอที่จะเรียกใช้โปรแกรมประยุกต์ที่ทำงานในการดำเนินงานร่วมกันหน่วยความจำแบบดั้งเดิมระบบด้วยการปรับเปลี่ยนน้อยและจะทำเช่นนั้นในขณะที่การปรับที่มีจำนวนเพิ่มมากขึ้นของแกน. เพื่อให้บรรลุเป้าหมายนี้กระต่ายต้อง คุณสมบัติสนับสนุน (เช่นอธิบายไฟล์ที่ใช้ร่วมกัน) เครือข่ายแบบดั้งเดิมที่มีระบบไฟล์ไม่สนับสนุนเช่นเดียวกับการใช้พวกเขาในทางที่เครื่องชั่ง(เช่น Shard ไดเรกทอรีในเซิร์ฟเวอร์เพื่อให้พร้อมกันดำเนินงานในไดเรกทอรีที่) กระต่ายบรรลุเป้าหมายนี้ผ่านการรวมกันของโปรโตคอลใหม่ (รวม 3 เฟสกระทำโปรโตคอลที่จะใช้การดำเนินการอย่างถูกต้องและไดเรกทอรีscalably) และใช้ประโยชน์จากคุณสมบัติของการไม่สอดคล้องกันแคชมัลติ(เช่นการส่งข้อความ latency ต่ำอะตอมและDRAM ที่ใช้ร่วมกัน) การประเมินผลบนเครื่อง 40-core แสดงให้เห็นว่ากระต่ายสามารถเรียกใช้โปรแกรมลินุกซ์ที่ท้าทายหลายคน(รวมทั้งเซิร์ฟเวอร์อีเมลและสร้างเคอร์เนลลินุกซ์) ที่มีน้อยที่สุดหรือไม่มีการแก้ไข ผลยังแสดงให้เห็นการใช้งานเหล่านี้เกิดการขยายระบบที่ดีในกระต่ายและเทคนิคของกระต่ายมีความสำคัญต่อการบรรลุscalability

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

กระต่ายใหม่เป็นระบบแฟ้มที่มีอินเตอร์เฟซ
บนโปรเซสเซอร์ multicore POSIX เช่นโดยไม่ต้องแคชสัมพันธ์กัน ช่วยให้การใช้งานบนกระต่าย
แกนต่าง ๆ เพื่อแชร์ไฟล์และไดเรกทอรี ,
ในไฟล์ ความท้าทายในการออกแบบกระต่าย
คือการสนับสนุนร่วมกันนามธรรมอย่างเพียงพอที่จะใช้โปรแกรมประยุกต์ที่ใช้แบบดั้งเดิม

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