ฉันได้ยินมาว่าการสร้างกระบวนการใหม่ในกล่อง Windows มีราคาแพงกว่าบน Linux นี่คือเรื่องจริง? ใครสามารถอธิบายเหตุผลทางเทคนิคว่าทำไมราคาแพงกว่าและให้เหตุผลทางประวัติศาสตร์สำหรับการตัดสินใจออกแบบเบื้องหลังเหตุผลเหล่านั้น

mweerden: NT ได้รับการออกแบบมาสำหรับผู้ใช้หลายคนตั้งแต่วันแรกดังนั้นนี่จึงไม่ใช่เหตุผลจริงๆ อย่างไรก็ตามคุณพูดถูกเกี่ยวกับการสร้างกระบวนการดังกล่าวมีบทบาทสำคัญน้อยกว่าใน NT มากกว่า Unix เป็น NT ซึ่งตรงกันข้ามกับ Unix สนับสนุนการทำงานแบบมัลติเธรดมากกว่าการประมวลผลหลายขั้นตอน

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

เมื่อพูดถึงความเร็วของการสร้างกระบวนการอาจเป็นความคิดที่ดีที่จะแยกความแตกต่างระหว่าง NT และ Windows / Win32 เท่าที่ NT (เช่นเคอร์เนลเอง) ไปฉันไม่คิดว่าการสร้างกระบวนการ (NtCreateProcess) และการสร้างเธรด (NtCreateThread) จะช้าลงอย่างมากเมื่อเทียบกับ Unix โดยเฉลี่ย อาจมีอะไรเกิดขึ้นอีกเล็กน้อย แต่ฉันไม่เห็นเหตุผลหลักของความแตกต่างของประสิทธิภาพที่นี่

อย่างไรก็ตามหากคุณดู Win32 คุณจะสังเกตเห็นว่ามันเพิ่มค่าใช้จ่ายในการสร้างกระบวนการ ประการแรกต้องมีการแจ้ง CSRSS เกี่ยวกับการสร้างกระบวนการซึ่งเกี่ยวข้องกับ LPC ต้องมีการโหลดอย่างน้อย kernel32 เพิ่มเติมและต้องดำเนินการรายการงานการทำบัญชีเพิ่มเติมอีกจำนวนหนึ่งก่อนที่กระบวนการจะถือว่าเป็นกระบวนการ Win32 ที่สมบูรณ์ และอย่าลืมเกี่ยวกับค่าโสหุ้ยเพิ่มเติมทั้งหมดที่กำหนดโดยการแยกไฟล์ Manifest ตรวจสอบว่ารูปภาพต้องการ Shim ที่เข้ากันได้หรือไม่ตรวจสอบว่าใช้นโยบายการ จำกัด ซอฟต์แวร์หรือไม่ yada yada

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

Unix มีการเรียกระบบ 'fork' ซึ่ง 'แยก' กระบวนการปัจจุบันออกเป็นสองส่วนและให้กระบวนการที่สองที่เหมือนกับกระบวนการแรก (modulo the return from the fork call) เนื่องจากพื้นที่แอดเดรสของกระบวนการใหม่เริ่มทำงานแล้วจึงควรถูกกว่าการเรียก 'CreateProcess' ใน Windows และการโหลดรูปภาพ exe, dll ที่เกี่ยวข้อง ฯลฯ

ในกรณีส้อมระบบปฏิบัติการสามารถใช้ความหมาย 'copy-on-write' สำหรับเพจหน่วยความจำที่เชื่อมโยงกับกระบวนการใหม่ทั้งสองเพื่อให้แน่ใจว่าแต่ละหน้าได้รับสำเนาของหน้าที่จะแก้ไขในภายหลัง

การเพิ่มสิ่งที่ JP กล่าว: ค่าใช้จ่ายส่วนใหญ่เป็นของการเริ่มต้น Win32 สำหรับกระบวนการนี้

เคอร์เนลของ Windows NT รองรับ COW fork SFU (สภาพแวดล้อม UNIX ของ Microsoft สำหรับ Windows) ใช้ อย่างไรก็ตาม Win32 ไม่รองรับ fork กระบวนการ SFU ไม่ใช่กระบวนการ Win32 SFU ตั้งฉากกับ Win32: ทั้งคู่เป็นระบบย่อยของสภาพแวดล้อมที่สร้างขึ้นบนเคอร์เนลเดียวกัน

นอกเหนือจากการเรียก LPC ที่CSRSSไม่อยู่ในกระบวนการแล้วใน XP และหลังจากนั้นยังมีการเรียกใช้เอ็นจินความเข้ากันได้ของแอปพลิเคชันเพื่อค้นหาโปรแกรมในฐานข้อมูลความเข้ากันได้ของแอปพลิเคชัน ขั้นตอนนี้ทำให้เกิดค่าใช้จ่ายเพียงพอที่ Microsoft มีตัวเลือกนโยบายกลุ่มเพื่อปิดใช้งานเอ็นจินความเข้ากันได้บน WS2003ด้วยเหตุผลด้านประสิทธิภาพ

ไลบรารีรันไทม์ Win32 (kernel32.dll ฯลฯ ) ยังทำการอ่านและเริ่มต้นรีจิสทรีจำนวนมากเมื่อเริ่มต้นระบบที่ไม่ได้ใช้กับ UNIX, SFU หรือกระบวนการดั้งเดิม

กระบวนการดั้งเดิม (ที่ไม่มีระบบย่อยของสภาพแวดล้อม) นั้นสร้างได้รวดเร็วมาก SFU ทำงานน้อยกว่า Win32 มากสำหรับการสร้างกระบวนการดังนั้นกระบวนการจึงสร้างได้รวดเร็วเช่นกัน

อัปเดตสำหรับปี 2019: เพิ่ม LXSS: Windows Subsystem for Linux

การแทนที่ SFU สำหรับ Windows 10 เป็นระบบย่อยสภาพแวดล้อม LXSS เป็นโหมดเคอร์เนล 100% และไม่ต้องการ IPC ใด ๆ ที่ Win32 ยังคงมีอยู่ Syscall สำหรับกระบวนการเหล่านี้ถูกส่งไปยัง lxss.sys / lxcore.sys โดยตรงดังนั้น fork () หรือกระบวนการอื่น ๆ ที่สร้างการโทรจะมีค่าใช้จ่ายเพียง 1 การเรียกระบบสำหรับผู้สร้างทั้งหมด [พื้นที่ข้อมูลที่เรียกว่าอินสแตนซ์] ติดตามกระบวนการ LX เธรดและสถานะรันไทม์ทั้งหมด

กระบวนการ LXSS ขึ้นอยู่กับกระบวนการดั้งเดิมไม่ใช่กระบวนการ Win32 สิ่งที่เฉพาะเจาะจงของ Win32 ทั้งหมดเช่นเอ็นจิ้นความเข้ากันได้ไม่มีส่วนร่วมเลย

นอกเหนือจากคำตอบของ Rob Walker: ทุกวันนี้คุณมีสิ่งต่างๆเช่น Native POSIX Thread Library - หากคุณต้องการ แต่เป็นเวลานานแล้ววิธีเดียวที่จะ "มอบหมาย" ให้กับงานในโลกยูนิกซ์คือการใช้ fork () (และยังคงเป็นที่ต้องการในหลาย ๆ สถานการณ์) เช่นเซิร์ฟเวอร์ซ็อกเก็ตบางประเภท

socket_accept ()
ส้อม()
ถ้า (เด็ก)
    handleRequest ()
อื่น
    goOnBeingParent ()

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

ระบบที่ใช้ Unix เดิมเป็นระบบและเซิร์ฟเวอร์ที่มีผู้ใช้หลายคน โดยเฉพาะอย่างยิ่งในช่วงหลังไม่ใช่เรื่องแปลกที่จะมีโปรเซส (เช่นเมลหรือ http daemons) ที่แยกกระบวนการออกเพื่อจัดการกับงานเฉพาะ (เช่นการดูแลการเชื่อมต่อขาเข้า) ปัจจัยสำคัญในการทำเช่นนี้คือforkวิธีการราคาถูก(ตามที่ Rob Walker ( 47865 ) กล่าวไว้ในตอนแรกใช้หน่วยความจำเดียวกันสำหรับกระบวนการที่สร้างขึ้นใหม่) ซึ่งมีประโยชน์มากเนื่องจากกระบวนการใหม่มีข้อมูลทั้งหมดที่ต้องการทันที

เป็นที่ชัดเจนว่าอย่างน้อยในอดีตความจำเป็นที่ระบบที่ใช้ Unix จะต้องมีการสร้างกระบวนการที่รวดเร็วนั้นมากกว่าระบบ Windows ฉันคิดว่ายังคงเป็นเช่นนั้นเนื่องจากระบบที่ใช้ Unix ยังคงเน้นกระบวนการมากในขณะที่ Windows เนื่องจากประวัติของมันน่าจะเน้นเธรดมากกว่า (เธรดที่มีประโยชน์ในการสร้างแอปพลิเคชันที่ตอบสนอง)

Disclaimer: ฉันไม่ได้เป็นผู้เชี่ยวชาญในเรื่องนี้ดังนั้นโปรดยกโทษให้ฉันหากฉันเข้าใจผิด

เอ่อดูเหมือนจะมีเหตุผล "มันดีกว่าวิธีนี้" เกิดขึ้นมากมาย

ฉันคิดว่าผู้คนจะได้รับประโยชน์จากการอ่าน "Showstopper"; หนังสือเกี่ยวกับการพัฒนา Windows NT

เหตุผลทั้งหมดที่บริการทำงานเป็น DLL ในกระบวนการเดียวบน Windows NT คือการทำงานช้าเกินไปเนื่องจากเป็นกระบวนการแยกกัน

หากคุณรู้สึกแย่และสกปรกคุณจะพบว่ากลยุทธ์การโหลดไลบรารีเป็นปัญหา

ใน Unices (โดยทั่วไป) ส่วนของรหัสไลบรารีที่ใช้ร่วมกัน (DLL) จะถูกแชร์จริง

Windows NT จะโหลดสำเนาของ DLL ต่อกระบวนการเนื่องจากจัดการกับส่วนของรหัสไลบรารี (และส่วนของรหัสที่ปฏิบัติการได้) หลังจากการโหลด (บอกว่าข้อมูลของคุณอยู่ที่ไหน)

ส่งผลให้โค้ดเซกเมนต์ในไลบรารีไม่สามารถใช้ซ้ำได้

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

บางครั้งก็ต้องจ่ายเงินในทางวิศวกรรมถึงขั้นถอยหลังแล้วพูดว่า "ตอนนี้ถ้าเราจะออกแบบสิ่งนี้ให้ห่วยจริงมันจะเป็นยังไง"

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

คำตอบสั้น ๆ คือ "เลเยอร์ซอฟต์แวร์และส่วนประกอบ"

สถาปัตยกรรม windows SW มีเลเยอร์และส่วนประกอบเพิ่มเติมสองสามอย่างที่ไม่มีอยู่ใน Unix หรือถูกทำให้ง่ายขึ้นและจัดการภายในเคอร์เนลบน Unix

ใน Unix นั้น fork และ exec เป็นการเรียกโดยตรงไปยังเคอร์เนล

ใน Windows ไม่ได้ใช้ kernel API โดยตรงมี win32 และส่วนประกอบอื่น ๆ อยู่ด้านบนดังนั้นการสร้างกระบวนการต้องผ่านเลเยอร์พิเศษจากนั้นกระบวนการใหม่จะต้องเริ่มต้นขึ้นหรือเชื่อมต่อกับเลเยอร์และส่วนประกอบเหล่านั้น

สำหรับค่อนข้างบางเวลานักวิจัยและ บริษัท ได้พยายามที่จะเลิก Unix ในลักษณะที่คล้ายรางมักจะยึดการทดลองของพวกเขาในเคอร์เนล Mach ; ตัวอย่างที่รู้จักกันดีคือOS X ได้ ทุกครั้งที่พวกเขาพยายามมันจะช้าลงอย่างน้อยที่สุดพวกเขาก็รวมชิ้นส่วนกลับเข้าไปในเคอร์เนลอย่างถาวรหรือสำหรับการจัดส่งเพื่อการผลิต

เนื่องจากดูเหมือนว่าจะมีเหตุผลบางประการของ MS-Windows ในบางคำตอบเช่น

• “ เคอร์เนล NT และ Win32 ไม่ใช่สิ่งเดียวกัน ถ้าคุณตั้งโปรแกรมเป็นเคอร์เนล NT มันก็ไม่ได้แย่ขนาดนี้” - จริง แต่ถ้าคุณไม่เขียนระบบย่อย Posix แล้วใครจะสนล่ะ คุณจะเขียนถึง win32
• “ มันไม่ยุติธรรมเลยที่จะเปรียบเทียบ fork กับ ProcessCreate เนื่องจากพวกมันทำสิ่งที่แตกต่างกันและ Windows ก็ไม่มี fork” - จริงดังนั้นผมจะเปรียบเทียบกับ like อย่างไรก็ตามฉันจะเปรียบเทียบ fork ด้วยเพราะมันมีหลายกรณีการใช้งานเช่นการแยกกระบวนการ (เช่นแต่ละแท็บของเว็บเบราว์เซอร์ทำงานในกระบวนการที่แตกต่างกัน)

ตอนนี้ให้เรามาดูข้อเท็จจริงว่าประสิทธิภาพแตกต่างกันอย่างไร?

ข้อมูล summerised จาก http://www.bitsnbites.eu/benchmarking-os-primitives/
เนื่องจากความลำเอียงเป็นสิ่งที่หลีกเลี่ยงไม่ได้เมื่อสรุปฉันจึงสนับสนุนฮาร์ดแวร์MS-Windows
สำหรับการทดสอบส่วนใหญ่ i7 8 core 3.2GHz ยกเว้น Raspberry-Pi ที่รัน Gnu / Linux

หมายเหตุ: ในลินุกซ์ได้เร็วขึ้นว่าวิธีการที่ต้องการfork MS-หน้าต่างCreateThread

ตัวเลขสำหรับการดำเนินการประเภทการสร้างกระบวนการ (เนื่องจากยากที่จะเห็นค่าของ Linux ในแผนภูมิ)

ตามลำดับความเร็วเร็วที่สุดไปช้าที่สุด (ตัวเลขคือเวลาเล็กดีกว่า)

• ลินุกซ์ CreateThread 12
• Mac CreateThread 15
• ลินุกซ์ส้อม 19
• Windows CreateThread 25
• Linux CreateProcess (fork + exec) 45
• แม็คส้อม 105
• Mac CreateProcess (fork + exec) 453
• Raspberry-Pi CreateProcess (fork + exec) 501
• Windows CreateProcess 787
• Windows CreateProcess พร้อมโปรแกรมสแกนไวรัส 2850
• Windows Fork (จำลองด้วย CreateProcess + fixup) ขูดมากกว่า 2850

ตัวเลขสำหรับการวัดอื่น ๆ

• การสร้างไฟล์
  • ลินุกซ์ 13
  • แม็ค 113
  • Windows 225
  • Raspberry-Pi (พร้อมการ์ด SD ช้า) 241
  • Windows พร้อมเครื่องป้องกันและโปรแกรมสแกนไวรัส ฯลฯ 12950
• การจัดสรรหน่วยความจำ
  • ลินุกซ์ 79
  • วินโดวส์ 93
  • Mac 152

ทั้งหมดนั้นมีความจริงที่ว่าในเครื่อง Win ส่วนใหญ่ซอฟต์แวร์ป้องกันไวรัสจะเริ่มทำงานในระหว่าง CreateProcess ... ซึ่งมักจะเป็นการชะลอตัวที่ใหญ่ที่สุด

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