อเล็กเซย์ โรมาเนนโก:ฉันชื่อ Alexey Romanenko ฉันทำงานที่ RBC หัวข้อของรายงานนี้ค่อนข้างขัดแย้ง ดูเหมือนว่าทำไมต้องคอมไพล์สคริปต์ PHP ในเมื่อทุกอย่างดูเหมือนจะทำงานเช่นนั้น?
คำถามหลักอาจเป็น: "ทำไม" โดยทั่วไป จุดประสงค์ของการนำเสนอนี้คือเพื่อพยายามทำความเข้าใจว่าจำเป็นต้องมีการรวบรวมดังกล่าวหรือไม่ หากเป็นเช่นนั้น ทำไม ในรูปแบบใด และเพื่อใคร
คอมไพเลอร์ PHP คืออะไร?
ขั้นแรก มาดูภาพรวมโดยย่อว่า PHP Compiler คืออะไร ฉันจะบอกคุณว่ามันทำงานอย่างไร มันคืออะไร และคุณจะเร่งความเร็วได้อย่างไร
โมดูลการทำงานแรกคือสิ่งที่เรียกว่า SAPI (Server API) ซึ่งมีอินเทอร์เฟซสำหรับการเข้าถึง PHP จากไคลเอนต์ต่างๆ (Apache, เซิร์ฟเวอร์ CGI บางประเภท (Common Gateway Interface) และอื่น ๆ ) นอกจากนี้ยังมี SAPI ฝังอยู่ซึ่งช่วยให้คุณสามารถฝัง PHP ลงในแอปพลิเคชันใดก็ได้
ส่วนหลักที่สองคือ PHP Core ซึ่งประมวลผลคำขอ ใช้งานทั้งหมดกับเครือข่าย ระบบไฟล์ และแยกวิเคราะห์สคริปต์ด้วยตนเอง
ส่วนสากลที่สามคือ Zend Engine ซึ่งรวบรวมสคริปต์ของเราเป็นไบต์โค้ดบางส่วน รันสคริปต์บนเครื่องเสมือน และจัดการการจัดการหน่วยความจำ (ใช้ตัวจัดสรรที่ครอบคลุม)
ส่วนที่สำคัญและใหญ่ที่สุดส่วนหนึ่งคือโมดูลส่วนขยาย ซึ่งใช้งาน 99% ของสิ่งที่เราใช้ใน PHP สิ่งเหล่านี้อาจเป็น "ตัวห่อหุ้ม" สำหรับบางไลบรารี หรือฟังก์ชันการทำงาน หรือคลาส ไลบรารีในตัว ฯลฯ เรายังสามารถเขียนส่วนขยายของเราเองได้
สคริปต์ทำงานอย่างไร?
อันดับแรก. การวิเคราะห์คำศัพท์เกิดขึ้น - ไฟล์ถูกดาวน์โหลด, แยกวิเคราะห์, อักขระทั้งหมดจากชุดของไฟล์นี้จะถูกแปลเป็นชุดโทเค็นบางชุดซึ่งเราจะใช้งานด้วย
ขั้นตอนการแยกวิเคราะห์แยกวิเคราะห์โทเค็นเหล่านี้ จากการวิเคราะห์นี้ โครงสร้างทางไวยากรณ์บางอย่างจะถูกรวบรวม โดยพื้นฐานแล้วจะสร้างโค้ดไบต์
ในตอนท้าย Zend Engine จะดำเนินการดังกล่าว ผลลัพธ์จะถูกส่งกลับไปยังลูกค้า
เรากำลังพูดถึงภาระที่สูง หากคุณทำซ้ำขั้นตอนนี้ทุกครั้ง ทุกอย่างจะทำงานช้ามาก เมื่อล่ามของเราได้รับคำขอหลายแสนหรือพันคำขอในเวลาเดียวกัน ความเร็วก็แทบจะไม่มีอยู่เลย
แต่มีวิธีแก้ปัญหา พวกเขารู้จักกันมานานแล้ว
จะเร่งความเร็วได้อย่างไร?
วิธีแก้ปัญหาที่ง่ายที่สุด ถูกที่สุด และผ่านการทดสอบมาอย่างดีคือการแคชโค้ดไบต์ แทนที่จะผ่านขั้นตอนการแยกวิเคราะห์ เราเพียงแค่แคชโค้ดไบต์ของเรา มีส่วนขยายพิเศษสำหรับสิ่งนี้ - ทุกคนที่ทำงานกับ PHP เป็นที่รู้จักกันดี - ได้แก่ APC, eAccelerator, Xcache และอื่น ๆ Zend Engine เพียงเรียกใช้โค้ดไบต์
ตัวเลือกที่สองคือการจัดทำโปรไฟล์โค้ด การระบุจุดคอขวด เราสามารถเขียนบางสิ่งใหม่เป็นส่วนขยาย PHP (ซึ่งจะเป็นส่วนขยายใน C/C++) คอมไพล์และใช้เป็นโมดูล
ตัวเลือกที่สามเป็นแบบสากลมากขึ้น - ลืมเกี่ยวกับ PHP แล้วเขียนทุกอย่างใหม่ โดยทั่วไปตัวเลือกนี้มีสิทธิ์ในชีวิต แต่เฉพาะในกรณีที่โค้ด PHP ไม่เพียงพอ ในโครงการขนาดใหญ่ขนาดใหญ่ (หรือที่มีอยู่มาเป็นเวลานาน) มักจะสะสมจำนวนมากและจะใช้เวลานานในการเขียนใหม่ทั้งหมด ข้อกำหนดทางธุรกิจจะไม่อนุญาตให้คุณทำเช่นนี้ โดยทั่วไปแล้ว การเขียนบางอย่างด้วย PHP เช่น สำหรับเซิร์ฟเวอร์ส่วนหน้านั้นใช้เวลาไม่นานเกินไป เพราะเป็นภาษาที่เข้าใจง่าย ช่วยให้คุณทำสิ่งที่ใช้เวลานานกว่าในภาษาระดับต่ำได้อย่างรวดเร็ว
มีตัวเลือกอื่นซึ่งเพิ่งแพร่หลายเมื่อไม่นานมานี้ นั่นคือการรวบรวม PHP ที่ไหนสักแห่งให้กลายเป็นสิ่งที่เร็วกว่า
มารวบรวมอะไรบางอย่างกัน?
คำว่า "คอมไพล์" ฉันจะหมายถึงการแปลโค้ดสคริปต์ PHP เป็นอย่างอื่นเป็นโค้ดอื่น
ในกรณีนี้อาจมีได้สองประเภท
รหัสเนทิฟเป็นไฟล์ไบนารีชนิดหนึ่งที่สามารถเรียกใช้งานบนเครื่องจริงได้
รหัสที่ไม่ใช่เจ้าของภาษา คุณสามารถคอมไพล์โค้ดไบต์บางส่วนที่สามารถดำเนินการบนเครื่องเสมือนอื่นได้ เช่น บน JVM
คุณจะรวบรวมโค้ดเนทิฟจาก PHP ได้อย่างไร?
คอมไพเลอร์โรดเซนด์ ภาคต่อของมันคือ Raven นอกจากนี้ยังมี PHC (นี่คือคอมไพเลอร์ PHP Open Source) ล่าสุดวงการฮิปฮอป (Facebook) ก็ปรากฏตัวเช่นกัน
ฉันจะให้ภาพรวมสั้นๆ เกี่ยวกับสิ่งที่สามารถทำได้สำหรับโค้ดที่ไม่ใช่เจ้าของภาษา เท่าที่ฉันรู้มี 3 ตัวเลือกการทำงาน นี่คือการสร้างไบต์โค้ดสำหรับ Java และการสร้างไบต์โค้ดสำหรับ .Net: Quercus, Project Zero, Phalanger ฉันจะไม่พิจารณาการคอมไพล์เป็นโค้ดที่ไม่ใช่เนทีฟเพราะเราไม่ได้ใช้มัน กลับมาที่การคอมไพล์เป็นโค้ดเนทีฟกัน
ในความคิดของฉัน คอมไพเลอร์ที่เก่าแก่ที่สุดคือ Roadsend เริ่มมีการพัฒนาเมื่อนานมาแล้วเมื่อปี พ.ศ. 2545 เดิมทีเป็นแอปพลิเคชั่นเชิงพาณิชย์ มันถูกปิดลง เฉพาะในปี 2550 เท่านั้นที่เผยแพร่สู่โอเพ่นซอร์ส มีรูปแบบการคอมไพล์ที่ซับซ้อนมาก: คอมไพเลอร์ Bigloo บางตัวใช้สำหรับภาษา Scheme หลังจากนั้นจึงสร้างโค้ดเนทีฟขึ้นมา คอมไพเลอร์นี้ไม่ได้ใช้ Zend Engine
เราสามารถสร้างไบนารีปฏิบัติการแยกต่างหากหรือสร้างโมดูลสำหรับ Apache ได้ นอกจากนี้ยังสามารถสร้างไบนารี่ที่จะทำงานเป็นเว็บเซิร์ฟเวอร์ได้อีกด้วย แต่มันไม่ทำงาน ฉันไม่รู้ว่าทำไม แต่มันก็ไม่ได้ผลสำหรับฉันเลย
เท่าที่ฉันรู้ งาน Roadsend ยังไม่ได้ดำเนินการอยู่ในขณะนี้ พัฒนาเป็นโปรเจ็กต์ Raven ซึ่งได้รับการเขียนใหม่ทั้งหมดด้วยภาษา C++ ในฐานะคอมไพเลอร์ จะใช้ LLVM เพื่อสร้างโค้ด
ในขณะนี้ทุกอย่างดูมีแนวโน้มมาก
แต่ก็ยังอยู่ระหว่างการก่อสร้าง แม้แต่ในเอกสารประกอบก็ยังมีคำใบ้ว่าเราจะไม่สร้างไบนารี รอ.
สิ่งต่างๆ คงจะเศร้าถ้าเราไม่มี PHC นี่คือคอมไพเลอร์ OpenSource ได้รับการพัฒนามาตั้งแต่ปี 2548 ข้อเสียประการหนึ่ง: ใช้ SAPI ในตัว เราจะไม่ละทิ้งเครื่อง Java นั่นคือ Zend Engine โดยพื้นฐานแล้วจะแปลโค้ด PHP เป็นโค้ดโมดูลส่วนขยาย PHP หลังจากนั้นจะคอมไพล์ แต่กระบวนการดำเนินการเกี่ยวข้องกับ Zend Engine อีกครั้ง
ตัวอย่างการใช้ PHC
คล้ายกับวิธีการทำงานของเรามาก เช่น กับคอมไพเลอร์ทั่วไป gcc อันแรกแสดงว่ามีไบนารีหนึ่งตัว เรายังสามารถสร้างโค้ด C ได้อีกด้วย เนื่องจากมีการใช้ gcc เดียวกันภายในหลังจากสร้างโค้ดนี้ เราจึงสามารถใช้แฟล็กเหล่านั้นที่มีไว้เพื่อการเพิ่มประสิทธิภาพและอื่นๆ ได้
เรากำลังพูดถึงแอปพลิเคชันที่ทำงานบนบรรทัดคำสั่ง
ในการเปิดแอปพลิเคชันเว็บ คุณต้องดำเนินการหลายขั้นตอนซึ่งค่อนข้างซับซ้อน ก่อนอื่นคุณต้องสร้างส่วนขยาย จากนั้นคอมไพล์โค้ด จากนั้นจึงทำการเชื่อมต่อ (ทั้งแบบไดนามิกหรือแบบคงที่)
ประโยชน์ที่สำคัญของ PHC
โดยพื้นฐานแล้ว เราใช้ PHP เดียวกัน เราเข้ากันได้อย่างสมบูรณ์ รองรับส่วนขยายอื่น ๆ ทั้งหมด เราใช้ทุกสิ่งที่เรารวบรวม เอกสารค่อนข้างดี
อย่างไรก็ตาม โบนัสเพิ่มเติมประการหนึ่งของ PHC คือคุณสามารถสร้างงาน XML ของสคริปต์ของเราตามวิธีสร้าง XML ซึ่งบางครั้งก็อาจมีประโยชน์
ข้อเสีย
ในความคิดของฉัน นี่เป็นไบนารีที่ด้อยกว่า เนื่องจากยังคงต้องพึ่งพา Zend Engine นอกจากนี้ยังมีความซับซ้อนในแง่ของการเชื่อมต่อโครงการเว็บ
เกี่ยวกับสิ่งสำคัญ
รายงานนี้คงไม่เกิดขึ้นหาก HipHop ซึ่งเป็นโซลูชันจาก Facebook ไม่ปรากฏขึ้น ผู้สร้างยังสะสมโค้ด PHP จำนวนมากและคิดอยู่นานว่าจะทำอย่างไรกับมัน
ตามที่ฉันเข้าใจ หลังจากที่ตัวเลือกในการเขียนใหม่ทุกอย่างถูกปฏิเสธ ก็มีการตัดสินใจเขียนนักแปลบางประเภท (ในกรณีนี้เป็นโค้ด C++) โปรเจ็กต์นี้ยังค่อนข้างใหม่ เปิดตัวอย่างเป็นทางการในเดือนกุมภาพันธ์ปีนี้เท่านั้น โค้ด PHP ได้รับการแปลเป็นโค้ด C++ จากนั้นสร้างขึ้นโดยใช้เครื่องมือมาตรฐานบนระบบปฏิบัติการของคุณ อย่างไรก็ตาม ขณะนี้รองรับเฉพาะระบบปฏิบัติการ Linux เท่านั้น
เมื่อวานนี้ฉันถามตัวแทนของ Facebook เกี่ยวกับการตัดสินใจครั้งนี้ เขาบอกว่าปัจจุบันโค้ด PHP 100% ถูกคอมไพล์ผ่าน HipHop รหัสไม่ทำงานในรูปแบบบริสุทธิ์ผ่านล่าม PHP ผู้สร้างได้ประกาศการลดภาระของโปรเซสเซอร์ลงอย่างมากอีกครั้ง
ฟังก์ชั่นพื้นฐานของ HipHop
มันสร้างไบนารีขึ้นมาเองโดยตรง ซึ่งสามารถดำเนินการบนบรรทัดคำสั่งได้ มีตัวเลือกดังกล่าวสำหรับเปิดใช้งานเป็นเว็บเซิร์ฟเวอร์สตรีมมิ่ง นอกจากนี้ยังมีดีบักเกอร์ในตัวแยกต่างหาก สามารถดีบักสคริปต์ได้ทั้งภายในและระยะไกล (มันจะทำงานเป็นเซิร์ฟเวอร์)
กระบวนการประกอบค่อนข้างไม่สำคัญ มีคำอธิบายแต่ไม่ได้รวบรวมไว้ทุกที่ อย่างที่ฉันบอกไปในขณะนี้ ทุกอย่างประกอบขึ้นสำหรับ Linux และในตอนแรก ทุกอย่างได้รับการ "ปรับแต่ง" สำหรับ 64 บิต แม้ว่าขณะนี้ 32 บิตจะได้รับการสนับสนุนแบบทดลองแล้ว แต่ฉันจัดการเพื่อประกอบและปะแก้เล็กน้อย - โดยทั่วไปแล้วมันทำทั้งหมดนี้เพราะไม่ได้ประกอบโดยค่าเริ่มต้น
นอกจากนี้ พวกเขายังมี libcore เวอร์ชันของตัวเอง และในความคิดของฉัน มีไลบรารีอยู่สองสามไลบรารีที่ต้องแพตช์ด้วย โดยทั่วไปแล้ว กระบวนการประกอบนั้นไม่ง่ายขนาดนั้น
ที่เอาต์พุตหลังจากแอสเซมบลี เราได้รับไฟล์ hphp ซึ่งเป็นตัวแปลโค้ด PHP ของเราเป็น C++ หากดูจากธงแล้วก็มีค่อนข้างมาก ฉันได้เน้นสิ่งพื้นฐานบางประการที่คุณอาจต้องการไว้ที่นี่
เราสามารถใช้ไฟล์ในรูปแบบ HDF เป็นไฟล์กำหนดค่า (config) โดยระบุคำสั่งต่างๆ เราสามารถกำหนดระดับข้อผิดพลาดและสิ่งอื่นๆ ได้ (HDF คือทุกสิ่งที่มีอยู่ในรูปแบบที่มีโครงสร้าง) นอกจากนี้เรายังสามารถนำการกำหนดค่าเองจากฐานข้อมูลหรือใช้โดยตรงบนบรรทัดคำสั่ง
เราตั้งค่าระดับการบันทึกในระหว่างการคอมไพล์: แสดงข้อผิดพลาดทั้งหมดหรือแสดงคำเตือน ข้อมูลเพิ่มเติม หรือโดยทั่วไปจะเก็บบันทึกทั้งหมดของทุกสิ่งที่เกิดขึ้น
คำสั่งที่มีประโยชน์มากคือ input_list=FILE ซึ่งช่วยให้เราระบุรายการสคริปต์ที่เราต้องการคอมไพล์ได้ นอกจากนี้ยังควรกล่าวถึงคำสั่งเช่นlazy-bindด้วย เราสามารถระบุไฟล์โครงการทั้งหมดได้ - ไฟล์ที่จะคอมไพล์
ตัวอย่างการรันการคอมไพล์สคริปต์ PHP
ติดตั้งการบันทึกระดับที่สามแล้ว มีข้อมูลทั่วไปตรงเวลา คุณสามารถดูได้ว่าใช้เวลานานเท่าใด ที่จริงแล้วสคริปต์นั้นค่อนข้างง่าย นี่คือ "สวัสดีชาวโลก" ปกติ ฉันเพิ่งจับภาพหน้าจอ
ไฟล์ที่หนักที่สุดคือไบนารี "โปรแกรม" ของเราซึ่งมีขนาด 28 MB โดยพื้นฐานแล้ว "Hello, World" ของเรามีน้ำหนัก 28 MB ฉันต้องการทราบว่านอกเหนือจากบรรทัดมาตรฐาน "Echo "Hello, World!" แล้วไบนารีนี้ยังมีอีกมากมาย นี่คือเว็บเซิร์ฟเวอร์ที่มีคุณสมบัติครบถ้วนซึ่งเป็นเซิร์ฟเวอร์ที่มีคุณสมบัติครบถ้วนสำหรับการดูแลระบบ
เรากำลังทำอะไรอยู่?
เรามี “Hello…” ในภาษา C++ ซึ่งทำหน้าที่ประกอบด้วยหนึ่งบรรทัด “echo “Hello, World” นอกจากนี้ยังมีการโหลดข้อมูลจากบุคคลที่สามจำนวนมาก ดังที่เราเห็น นี่เป็นไฟล์เต็มรูปแบบ ในภาษาซี++
นี่คือผลลัพธ์ของโปรแกรม มันมีคีย์ที่แตกต่างกันอยู่สองสามคีย์สำหรับการกำหนดค่าที่แตกต่างกัน แต่ฉันจะพูดถึงเพียงบางส่วนเท่านั้น
นี่คือ --mode นี่คือโหมดการเปิดตัวโปรแกรมของเรา เราสามารถรันได้โดยตรง (จากบรรทัดคำสั่ง) หรือบนเว็บเซิร์ฟเวอร์หรือโหมด daemon เต็มรูปแบบ มีตัวเลือกเพิ่มเติมสองสามตัวแต่ไม่สำคัญ
config จะใช้ในรูปแบบเดียวกัน ฉันไม่ได้ให้คำสั่งเนื่องจากมีจำนวนมาก HipHop มาพร้อมเอกสารประกอบ ไม่ได้อยู่บนไซต์วิกิ แต่มีเอกสารประกอบการแจกจ่าย ซึ่งมีการอธิบายทุกอย่างไว้อย่างชัดเจน ฉันไม่ได้คาดหวังว่าคำอธิบายจะมีรายละเอียดมากขนาดนี้ ทำให้คุณสามารถกำหนดค่าโซลูชันได้อย่างยืดหยุ่น
หากต้องการทำงานในโหมดเซิร์ฟเวอร์เราสามารถระบุพอร์ตได้ สำหรับการดูแลระบบจะใช้พอร์ตแยกต่างหากซึ่งคุณสามารถส่งคำขอบางอย่างที่อนุญาตให้คุณจัดการเซิร์ฟเวอร์ได้ หากเรามีเซิร์ฟเวอร์การดีบักทำงานอยู่ เราจะระบุโฮสต์และพอร์ตที่เราจะ "เชื่อมโยง" สำหรับการดีบัก
เปิดตัวตัวอย่าง
ตัวอย่างเช่น เราระบุพอร์ต 9999 สำหรับการออกอากาศ โดยดำเนินการคำขอ http แบบธรรมดา เราสามารถรับสถิติหรือจัดการเซิร์ฟเวอร์ หรือรับข้อมูลเพิ่มเติมบางอย่างได้ โดยทั่วไปแล้วจะสะดวกมาก
ตัวเลือกในการรับข้อมูลสถานะ
สามารถรับสถานะเซิร์ฟเวอร์ที่กำหนดในรูปแบบบิวท์อินต่างๆ (xml, json, html) โดยพื้นฐานแล้ว มีการจัดเตรียมข้อมูลเกี่ยวกับกระบวนการหลักของเซิร์ฟเวอร์และตัวจัดการ - เธรดที่ประมวลผลคำขอ
สถิติเพิ่มเติม
ในความเป็นจริงมีสถิติให้มากมาย เนื่องจาก HipHop ทำงานร่วมกับ memcache และ SQL ในรูปแบบของ MySQL ได้โดยตรง จึงให้ข้อมูลโดยละเอียดเกี่ยวกับการดำเนินการทั้งหมดที่ดำเนินการด้วย
สถิติหน่วยความจำที่สมบูรณ์
มีคุณสมบัติที่มีประโยชน์มากที่นี่ - สถิติแอปพลิเคชัน การใช้ฟังก์ชันเพิ่มเติมของ HipHop ใน PHP ทำให้เราสามารถเขียนสถิติในสคริปต์ของเรา ซึ่งเราได้รับจากการเข้าถึง http เป็นประจำ
การดีบัก
ดังที่ฉันได้กล่าวไปแล้ว คุณสามารถใช้ "debug" ในตัวเพื่อดีบักสคริปต์ได้ สะดวกมากเพราะล่าม hppi ทำงานคล้ายกับสิ่งที่เรารวบรวมไว้ “พฤติกรรม” ของสคริปต์มีความแตกต่างกันเมื่อดำเนินการใน PHP มาตรฐานและเมื่อใช้ข้อมูลที่คอมไพล์บางส่วน เพื่อแก้ไขข้อบกพร่องที่คอมไพล์ Facebook ได้เขียนล่ามแยกต่างหาก
ในกรณีแรก เราจะรันโค้ดด้วยสวิตช์ “-f” และดูว่าไฟล์ทำงานอย่างไร เอาต์พุตทั้งหมดไปที่ stdout หรือเราสามารถรันในโหมดดีบักและเข้าสู่ดีบักเกอร์แบบโต้ตอบได้ มันคล้ายกับ GDB มาตรฐานมาก: คุณยังสามารถตั้งค่าเบรกพอยต์ รัน ป้อนค่าตัวแปร แทร็ก และอื่นๆ อีกมากมาย
หนึ่งในคุณสมบัติเพิ่มเติม
เรามีโปรแกรมที่ปรากฎหลังจากการคอมไพล์ สามารถใช้เป็นเซิร์ฟเวอร์ RPC ได้ เราเรียกใช้คำขอผ่าน http และโดยการเรียกใช้ฟังก์ชัน params เราสามารถส่งพารามิเตอร์เป็นอาร์เรย์ json หรือพารามิเตอร์แยกต่างหากได้ เราจะส่งคืน json ซึ่งจะส่งคืนผลลัพธ์ของฟังก์ชันเหล่านี้ สะดวกมาก - มีฟังก์ชันที่จำเป็นอยู่แล้วตั้งแต่เริ่มต้น
ข้อเสียของฮิปฮอป
ในขณะนี้ HipHop ไม่รองรับโครงสร้างภาษาและฟังก์ชันต่างๆ เช่น eval(), create_function() และ preg_replace() ด้วย /e แม้ว่าสิ่งเหล่านี้จะคล้ายคลึงกับ eval() ก็ตาม อย่างไรก็ตาม ในความคิดของฉัน รุ่นล่าสุด คุณยังสามารถเปิดใช้งาน eval() ผ่าน config ได้ แต่ไม่แนะนำให้ทำเช่นนี้ โดยทั่วไปแล้ว การใช้ eval() นั้นไม่ดี
ข้อดีหลักของฮิปฮอป
แน่นอนว่าข้อได้เปรียบหลักคือการสนับสนุนจาก Facebook มันใช้งานได้และกำลังได้รับการพัฒนาอย่างแข็งขัน ชุมชนนักพัฒนากำลังเกิดขึ้นรอบโครงการนี้ มีการเขียนการใช้งาน PHP ใหม่ทั้งหมดแล้ว
อย่างที่ฉันบอกไปแล้ว ข้อดีคือมีการสร้างโค้ดเนทีฟขึ้นมา การเพิ่มประสิทธิภาพสามารถอ้างสิทธิ์ได้โดยการลดต้นทุนการโหลดโปรเซสเซอร์ (การทดสอบยืนยันสิ่งนี้)
ค่อนข้างยืดหยุ่นในการกำหนดค่า ฉันรู้สึกประหลาดใจมากที่มีตัวเลือกในการปรับแต่งค่อนข้างน้อย ฉันคิดว่านี่เป็นเพราะว่าโครงการใช้งานได้จริง ทุกสิ่งที่ใช้ก็เพิ่มขึ้น
ดังที่ฉันได้กล่าวไปแล้ว HipHop มีคุณสมบัติเพิ่มเติมค่อนข้างมาก ซึ่งรวมถึงการใช้เป็นเซิร์ฟเวอร์ RPC การดูแลระบบ สถิติต่างๆ และอื่นๆ อีกมากมาย ยังมี API สำหรับการทำงานกับภาษาอื่นอีกด้วย
มีการเขียนเอกสารที่ค่อนข้างดีสำหรับโซลูชันนี้ ข้อดีอีกประการหนึ่ง: นี่คือโซลูชันที่พร้อมใช้งานจริงในการผลิต (ตัวอย่าง: Facebook)
ข้อเสีย
ข้อเสียเปรียบหลักคือ ในขณะนี้ รองรับโมดูลจำนวนค่อนข้างจำกัด ตัวอย่างเช่น เมื่อทำงานกับฐานข้อมูล เราสามารถใช้ฟังก์ชันสำหรับการทำงานกับ MySQL เท่านั้น ไม่มีการสนับสนุน PostgreSQL ที่นี่
นอกจากนี้ยังมีสิ่งที่ซับซ้อนในการประกอบซึ่งฉันได้กล่าวไปแล้ว มีปัญหากับการสร้างบนระบบ 32 บิต แต่ฉันคิดว่าสิ่งนี้จะได้รับการแก้ไขในไม่ช้า ในตอนนี้ ใช้เฉพาะการคอมไพล์จาก PHP 5.2 เท่านั้น เวอร์ชัน 5.3 ยังไม่รองรับ แต่จะได้รับการสนับสนุนตามที่สัญญาไว้
สิ่งที่คุณไม่ควรคาดหวังจากการรวบรวมโดยทั่วไปและโดยเฉพาะจากฮิปฮอป?
การคอมไพล์จะไม่ทำให้การสืบค้น SQL ที่ช้าของคุณในฐานข้อมูลเร็วขึ้นแต่อย่างใด หากคอขวดคือฐานข้อมูล ให้คอมไพล์หรือไม่คอมไพล์มันก็ไม่เกิดผลอะไร
การคอมไพล์ไม่ได้เพิ่มความเร็วในการโหลดแบบคงที่ แต่จะมีแต่การโหลดแบบไดนามิกเท่านั้น มันทำให้การดีบักยากขึ้นมาก หลายๆ คนคงคุ้นเคยกับความจริงที่ว่าทุกอย่างนั้นค่อนข้างง่ายในการแก้ไขใน PHP สิ่งนี้จะไม่เกิดขึ้นอีกต่อไประหว่างการรวบรวม แม้ว่าอย่างที่ฉันสังเกตเห็น Facebook จะทำให้กระบวนการนี้ง่ายที่สุดเท่าที่จะเป็นไปได้ แต่ถ้าไม่มีมันก็จะยากยิ่งขึ้นในการรวบรวมทุกครั้ง
อย่าคาดหวังว่านี่จะเป็น "กระสุนเงิน" ที่จะแก้ปัญหาทั้งหมดของคุณได้ ในความเป็นจริง การคอมไพล์ช่วยแก้ปัญหาได้ค่อนข้างแคบ หากเป็นเช่นนั้นสิ่งนี้อาจช่วยได้
การคอมไพล์แก้ปัญหาอะไรได้บ้าง?
จะช่วยลดภาระบน CPU เนื่องจากเมื่อทำงานกับ PHP และคำขอจำนวนมากโหลดบนมันจะเพิ่มขึ้นค่อนข้างมาก แน่นอนว่าฉันอยากจะทำการทดสอบบ้าง
การทดสอบ
การทดสอบครั้งแรก (วิธีที่ง่ายที่สุด) เป็นการดำเนินการที่ค่อนข้างแพงซึ่งใช้เวลาค่อนข้างนานจึงจะเสร็จสิ้น ในการทดสอบ ฉันพยายามสรุปตัวเองและไม่ส่งคำขอโดยใช้ทรัพยากรภายนอก
โหลดตกอยู่ที่โปรเซสเซอร์ทั้งหมด การทดสอบแสดงให้เห็นว่า HipHop "ชนะ" กับทุกคน: มันทำงานได้เร็วกว่าคอมไพเลอร์ PHP มาตรฐานเกือบหนึ่งเท่าครึ่ง ป.ล. ผ่านการทดสอบนี้ช้ามาก
สำหรับการทดสอบประสิทธิภาพครั้งที่สอง ฉันใช้สคริปต์ PHP อย่างเป็นทางการ ซึ่งสามารถดาวน์โหลดได้จาก SVN มันทำหน้าที่หลายอย่างที่ทำการเรียงลำดับ, การมอบหมาย, การรวม - การดำเนินการที่ค่อนข้างแพงจากมุมมองทางคณิตศาสตร์
ฮิปฮอปนำหน้าอีกครั้ง นอกจากนี้ ด้วย PHP มาตรฐาน เวลาจะต่างกันประมาณ 3 เท่า PHC ทำได้ดีกว่าที่นี่ แต่ก็แย่กว่าฮิปฮอปประมาณครึ่งหนึ่ง
PHP ส่วนใหญ่จะใช้สำหรับเธรดที่จัดการคำขอ http ซึ่งควรคำนึงถึง
การกำหนดค่ามาตรฐานหลายประการ (Apache พร้อม PHP, Nginx พร้อม fpm-php และ Plug-in APC สำหรับการแคชโค้ด) เป็นตัวเลือกที่ห้า - ฮิปฮอป
พูดตามตรง ฉันไม่ได้ทำการทดสอบบนเซิร์ฟเวอร์ แต่ทำบนแล็ปท็อป แน่นอนว่าตัวเลขอาจไม่ตรงกับความเป็นจริงทั้งหมด แต่ในกรณีนี้ ผลลัพธ์ก็ปกติ เป็นที่น่าสังเกตว่าเมื่อโหลดเพิ่มขึ้น จำนวนคำขอและจำนวนคำขอทั้งหมดก็จะเพิ่มขึ้นพร้อมกัน ต่อไปคือ RPS เราทดสอบหน้ามาตรฐานที่มีการรวมแบบง่าย 10 รายการ โดยพื้นฐานแล้ว นี่คือการทดสอบ PHP ในฐานะล่าม
คำถามจากผู้ฟัง:ตัวเลขในเซลล์ - วินาทีคืออะไร?
อเล็กเซย์ โรมาเนนโก:นี่คือเฟรมต่อวินาที
ที่นี่เราสามารถสรุปได้ว่าเมื่อจำนวนคำขอพร้อมกันเพิ่มขึ้น HipHop ก็ทำงานได้ดีมาก
จะเห็นได้ว่าการใช้ APC ถือเป็นแนวปฏิบัติมาตรฐาน มันแสดงให้เห็นว่ามันเพิ่ม เช่น เมื่อ Apache เพิ่มประสิทธิภาพประมาณ 2 เท่า สิ่งนี้ก็เกิดขึ้นกับ Nginx ด้วย แต่ความจริงที่ว่า Nginx ทำงานช้าไม่ได้หมายความว่าชุดค่าผสมนี้จะแย่ลง เป็นเพียงการทดสอบเฉพาะ หากเราทดสอบที่นี่จริงๆ Apache จะ “ตาย” ตามคำขอที่ช้า
เราอาจต้องการเข้าใจว่าเราต้องการสิ่งนี้หรือไม่
เมื่อใดที่คุณควรคิดถึงการรวบรวม?
เป็นไปได้มากว่าสิ่งนี้จำเป็นเมื่อเราเห็นว่าคอขวดของเราคือ CPU หากเราใช้งาน CPU-bound โดยใช้ PHP เป็นล่ามมาตรฐาน ก็อาจคุ้มค่าที่จะพิจารณาว่าบางทีส่วนหนึ่งของโปรเจ็กต์สามารถคอมไพล์ได้
ในบางกรณีเมื่อแอปพลิเคชันของคุณต้องการความเป็นอิสระในการทำงาน วิธีการนี้ไม่น่าจะเหมาะสม
การลดจำนวนเซิร์ฟเวอร์ เมื่อมีเซิร์ฟเวอร์จำนวนมาก ดังนั้นโดยการลดประสิทธิภาพการทำงานลง 2 เท่า พูดคร่าวๆ เราก็ลดจำนวนลงครึ่งหนึ่งด้วย เมื่อเป็นเซิร์ฟเวอร์เดียว มันก็ไม่สมเหตุสมผล แต่เมื่อมีจำนวน 100-200 เซิร์ฟเวอร์ ก็น่าจะสมเหตุสมผล
สาเหตุหลักที่ทำให้ Facebook เริ่มใช้ HipHop ก็คือการมีโค้ด PHP จำนวนมากซึ่งไม่มีทางที่จะเขียนใหม่ได้ (หรือไม่มีใครเลย หรือมีราคาแพง) เพิ่มผลผลิต 2 เท่าก็ดีอยู่แล้ว
อาจเป็นทุกอย่าง ฉันกำลังรอคำถามอยู่
คำถามและคำตอบ
คำถามจากผู้ฟัง:สวัสดี โปรดบอกฉันหากคุณมีตัวอย่างอื่นๆ ของการใช้งาน Hiphop ที่ประสบความสำเร็จ นอกเหนือจาก Facebook คุณต้องการโอนเว็บไซต์ RBC เช่น ไปยัง HipHop หรือไม่ อเล็กเซย์ โรมาเนนโก:ฉันจะเริ่มด้วยอันที่สอง เว็บไซต์ RBC แปลยาก เรื่องการนำไปปฏิบัติให้ประสบผลสำเร็จ ฉันคอมไพล์ PHP Unit ด้วยตัวเอง มันคอมไพล์ได้สำเร็จ เท่าที่ฉันรู้ บอร์ด PHP Bunty สามารถคอมไพล์ได้สำเร็จ จริงๆ แล้ว องค์กรจำนวนหนึ่งได้ใช้การคอมไพล์แล้ว การทดสอบเพิ่มเติมจะแสดงให้เห็นว่าการใช้โครงการนี้มีความสมเหตุสมผลเพียงใด คำถามจากผู้ฟัง:คุณช่วยยกตัวอย่างองค์กรที่ใช้งานมันได้ไหม? อเล็กเซย์ โรมาเนนโก:จริงๆ แล้วฉันจะไม่บอกคุณตอนนี้ แต่นี่คือตะวันตก เท่าที่ฉันรู้ไม่มีใครใช้ที่นี่ คำถามจากผู้ฟัง:อะไรคือความแตกต่างที่รันไทม์นอกเหนือจากการขาดการสนับสนุนสำหรับคุณสมบัติบางอย่างที่คุณกล่าวถึง การแปลโปรเจ็กต์ "สด" อันตรายแค่ไหน? อเล็กเซย์ โรมาเนนโก:ข้อแตกต่างก็คือโปรแกรมที่คอมไพล์แล้วอาจล้มเหลวได้ บางทีปัญหาบางอย่างอาจปรากฏขึ้นที่ยังไม่ได้ระบุ ในความเป็นจริง "พฤติกรรม" ของ PHP นั้นมีความแตกต่างกันหลายประการ ฉันไม่ได้รวมไว้เพราะสามารถดูข้อมูลโดยละเอียดเพิ่มเติมได้ในเอกสารประกอบ ทีมงาน Facebook เขียนล่ามของตัวเองซึ่งในความเป็นจริงแล้ว 99.9% เทียบเท่ากับล่ามที่จะทำงานในรูปแบบที่คอมไพล์แล้ว จะดีกว่าถ้าทดสอบโค้ดของคุณไม่ใช่ด้วยล่าม PHP มาตรฐาน แต่อย่างที่ผมบอกไปแล้วว่าใช้ hppi สำหรับ PHPการคอมไพล์ PHP จากซอร์สโค้ดมักทำบนระบบที่คล้าย Unix ผู้ที่ทำงานในสภาพแวดล้อม Windows OS มักจะดาวน์โหลดและติดตั้ง PHP จากแพ็คเกจไบนารี แม้ว่าฉันจะไม่เห็นด้วยว่าการใช้โซลูชันที่คอมไพล์ไว้ล่วงหน้านั้นง่ายกว่า แม้แต่บนระบบ Unix ก็ยังมีข้อดีบางประการที่มาพร้อมกับการคอมไพล์ไบนารี่จากแหล่งที่มา ทั้งหมดนี้:
- คุณมีความสามารถในการปรับแต่งผลิตภัณฑ์ขั้นสุดท้ายระหว่างการรวบรวม บางทีคุณอาจต้องการส่วนขยายบางอย่างที่คอมไพล์โดยตรงไปยังไบนารี่แทนที่จะโหลดเป็นไลบรารีภายนอก หรือบางทีคุณอาจต้องการปิดสิ่งที่โดยปกติจะมีให้ใช้งานตามค่าเริ่มต้น
- คุณสามารถทำเคล็ดลับได้ในระหว่างกระบวนการคอมไพล์หากจำเป็น ซึ่งอาจปรับปรุงประสิทธิภาพสำหรับสภาพแวดล้อมเฉพาะ (แน่นอนว่านี่ถือว่าคุณรู้อยู่แล้วว่าคุณกำลังทำอะไรอยู่ในกรณีนี้ คุณจะไม่อ่านบทความนี้ !).
- การคอมไพล์อาจเป็นวิธีเดียวที่จะทำให้สิ่งต่าง ๆ ทำงานได้หากไบนารีที่คอมไพล์นั้นสร้างจากซอฟต์แวร์และไลบรารีที่รองรับเวอร์ชันเก่า และตอนนี้คุณกำลังใช้งานบนระบบใหม่
คำเตือน:การคอมไพล์อาจทำให้หงุดหงิด โดยเฉพาะบน Windows! คุณต้องแน่ใจว่าสภาพแวดล้อมบิลด์ได้รับการตั้งค่าอย่างถูกต้อง เรียนรู้วิธีใช้คอมไพลเลอร์และเครื่องมือบิลด์อื่นๆ อย่างเหมาะสม และเป็นไปตามการขึ้นต่อกันของไลบรารี เราหวังว่าบทความนี้จะเป็นก้าวแรกของคุณในการเอาชนะอุปสรรคเหล่านี้
การตั้งค่าสภาพแวดล้อมการสร้าง
PHP เขียนด้วยภาษา C ดังนั้นจึงจำเป็นต้องมีคอมไพเลอร์ C หากคุณต้องการสร้าง PHP จากซอร์สโค้ด C++ เป็นชุดสุดยอดของ C ดังนั้นคอมไพเลอร์ C++ ที่ดีควรจะสามารถคอมไพล์โค้ด C ได้ และถึงแม้จะไม่ได้เป็นเช่นนั้นเสมอไปก็ตาม สำหรับ Windows, Visual Microsoft, C + + Express (ซึ่งต่อมาจะเรียกว่า VC + +) มีให้บริการฟรีบนเว็บไซต์ Microsoft ฉบับปี 2010 ถูกนำมาใช้
เมื่อเลือกเวอร์ชันคอมไพเลอร์ คุณควรจำไว้ว่าคุณจะรัน PHP อย่างไร หากคุณต้องทำงานกับ mod_php ของไบนารี Apache ที่คอมไพล์อย่างเป็นทางการ และต้องการคอมไพล์ PHP โดยใช้ Visual Studio 6 เนื่องจากนี่คือเวอร์ชันการคอมไพล์ Apache โมดูลจะต้องกำหนดเป้าหมายไลบรารีรันไทม์เดียวกันกับ Apache ในกรณีนี้คือ msvcrt.dll หากคุณกำลังสร้าง Apache จากแหล่งที่มาเช่นกัน หรือหากคุณจะใช้ PHP เป็น FastCGI หรือ CLI นี่ก็ไม่ใช่ปัญหา และปี 2010 ก็จะทำงานได้ดี
คุณต้องติดตั้งซอฟต์แวร์ Windows Development Kit (SDK) ด้วย SDK ให้ไฟล์ส่วนหัวที่สำคัญสำหรับแพลตฟอร์ม Windows แก่เราซึ่งเราจะต้องคอมไพล์ให้สำเร็จ นี่ก็ใช้เวอร์ชัน 7.1 เช่นกัน
ติดตั้งคอมไพเลอร์แล้วติดตั้ง SDK ฉันจะไม่หารือเกี่ยวกับการติดตั้งเนื่องจากทั้งคู่มีวิซาร์ดการติดตั้งแบบกราฟิกที่จะแนะนำคุณตลอดกระบวนการทั้งหมด
หากคุณมีบิลด์คอมไพเลอร์ที่ใช้งานได้ ให้ดาวน์โหลดเครื่องมือไบนารีและแพ็คเกจที่รู้จักจาก windows.php.net แพ็คเกจเครื่องมือไบนารี (ฉันใช้ไฟล์เก็บถาวร 20110915) มีเครื่องมือการพัฒนา เช่น re2c, bison และคำสั่งเพิ่มเติมบางส่วนที่คุณต้องใช้ในการสร้าง PHP แพ็คเกจที่รู้จัก (ฉันใช้ไฟล์เก็บถาวร 5.4 เนื่องจากมันตรงกับเวอร์ชัน PHP ที่ฉันจะรวบรวม) มีส่วนหัวขั้นต่ำและไลบรารีการพึ่งพาที่จำเป็น เช่น zlib.h
อาจดำเนินไปโดยไม่บอกว่าคุณต้องการดาวน์โหลดซอร์ส PHP เช่นกันจาก windows.php.net ในขณะที่เขียนบทความนี้ เวอร์ชันปัจจุบันของ PHP คือ 5.4.6 นั่นคือหมายเลขเวอร์ชันที่คุณจะเห็นในตัวอย่าง
เป็นความคิดที่ดีที่จะสร้างพื้นที่ทำงานที่คุณสามารถแยกซอร์สโค้ดและคอมไพล์มันเพื่อไม่ให้ส่งผลกระทบต่อส่วนที่เหลือของระบบของคุณ สร้างโฟลเดอร์ C:\PHP-Dev ที่จะทำหน้าที่เป็นไดเร็กทอรีการทำงานของคุณ จากนั้นแตกไฟล์เก็บถาวรไบนารีและเครื่องมือต่างๆ ลงไป
ถัดไป ให้แตกเนื้อหาของไฟล์เก็บถาวร ซอร์ส PHP ใน C:\PHP-Dev ตอนนี้คุณมี php5.4 ในโฟลเดอร์ซอร์ส แล้วแตกไฟล์เก็บถาวร deps ลงในโฟลเดอร์ deps Brother โครงสร้างไดเรกทอรีควรมีลักษณะดังนี้:
เปิดพรอมต์คำสั่ง Windows SDK ที่ติดตั้งด้วย SDK (Start => Microsoft Windows SDK => พรอมต์คำสั่ง Windows SDK) และเรียกใช้คำสั่งต่อไปนี้:
Setenv /release /xp /x86 cd C:\PHP-Dev bin\phpsdk_setvars.bat
การใช้บรรทัดคำสั่งคอนโซล SDK จะดีกว่าคอนโซล cmd.exe ทั่วไป เนื่องจากจะตั้งค่าตัวแปรสภาพแวดล้อมจำนวนมากสำหรับการคอมไพล์ซอร์สโค้ดโดยเฉพาะ การรวบรวมคำสั่งในภายหลังจะต้องดำเนินการในคอนโซลนี้ด้วย
setenv ตั้งค่าคุณสมบัติบิลด์บางอย่างสำหรับสภาพแวดล้อม ในกรณีนี้ สภาพแวดล้อมเป้าหมายคือบิลด์เวอร์ชัน Windows XP 32 บิต คุณสามารถลองสร้างด้วย /x64 หากคุณกำลังมองหาการผจญภัย การกำหนด Windows เวอร์ชันต่างๆ เช่น /Vista มักจะมีปัญหาด้านเอาท์พุตเนื่องจากมีคำจำกัดความแปลกๆ บางอย่างในสคริปต์ (PHP ยังคงต้องการให้เข้ากันได้กับ XP) เว้นแต่คุณจะรู้จริงๆ ว่าคุณกำลังทำอะไรอยู่ อาจปลอดภัยที่สุดที่จะยึดตามค่าที่แนะนำที่ฉันใช้ข้างต้น
สคริปต์ phpsdk_setvars.bat เข้าถึงตัวแปรสภาพแวดล้อมเพิ่มเติมบางส่วน กระบวนการสร้างสามารถค้นหาเครื่องมือไบนารี่ได้
โปรดทราบว่าการตั้งค่าตัวแปรทั้งหมดเหล่านี้เป็นเพียงเซสชันชั่วคราวในคอนโซลเท่านั้น หากคุณปิดทุกอย่างอย่างรวดเร็วเพื่อกลับมาคอมไพล์ในภายหลัง คุณจะต้องรันคำสั่งอีกครั้ง และหากไม่ปิด คุณจะได้รับข้อผิดพลาดดังต่อไปนี้ เมื่อคุณรัน configuration ในภายหลัง คุณจะไม่สามารถดำเนินการต่อได้:
กำลังตรวจสอบ bison.exe ...
ตรวจสอบให้แน่ใจว่าคุณมีสภาพแวดล้อมบิลด์ที่ถูกต้อง แหล่งที่มาที่จำเป็น และการขึ้นต่อกันใดๆ เป็นส่วนที่ยากที่สุดของกระบวนการ ตอนนี้สภาพแวดล้อมของคุณได้รับการตั้งค่าด้วยซอร์สโค้ดและการอ้างอิงแล้ว ถึงเวลาคอมไพล์!
การคอมไพล์ PHP
ที่บรรทัดคำสั่ง SDK ให้ไปที่โฟลเดอร์ซอร์ส PHP แล้วเรียกใช้ buildconf คำสั่งมีหน้าที่สร้างไฟล์คอนฟิกูเรชันที่ Makefile สร้างขึ้นเพื่อควบคุมกระบวนการคอมไพล์
หลังจาก buildconf เสร็จสิ้น (ใช้เวลาเพียงวินาทีเดียว) ให้รัน configuration --help - และตรวจสอบความช่วยเหลือเกี่ยวกับฟีเจอร์ที่คุณต้องการเปิด/ปิดใช้งาน จากนั้นรัน configuration อีกครั้งด้วยตัวเลือกใดก็ได้ที่คุณต้องการ เป็นความคิดที่ดีที่จะตรวจสอบเอาต์พุตก่อนทำการเคลื่อนย้าย เนื่องจากจะเตือนคุณหากไม่มีการขึ้นต่อกันที่จำเป็นใดๆ หากสิ่งนี้เกิดขึ้น คุณสามารถติดตั้งการขึ้นต่อกันและเรียกใช้การตั้งค่าอีกครั้ง หรือปรับการเรียกเพื่อปิดใช้งานส่วนขยายที่ต้องการ
สุดท้ายให้รัน NMAKE เพื่อเริ่มการคอมไพล์
Cd C:\PHP-Dev\php5.4 buildconf กำหนดค่าการทดสอบ nmake nmake
หากการกำหนดค่าหรือ NMAKE ล้มเหลว ปัญหาคือหนึ่งในสอง: ประการแรก สภาพแวดล้อมไม่ได้รับการกำหนดค่าอย่างถูกต้อง ประการที่สอง คุณได้เปิดใช้งานคุณสมบัติที่ขึ้นอยู่กับไลบรารีภายนอก และไลบรารีไม่ได้ติดตั้งบนระบบของคุณ ตรวจสอบอีกครั้งว่าคุณได้สร้างสภาพแวดล้อมตามคำแนะนำข้างต้น และได้มีการกำหนดค่าไลบรารีเพิ่มเติมที่อาจจำเป็นในการตั้งค่าการกำหนดค่าพื้นฐานแล้ว
เมื่อ NMAKE แรกของกระบวนการคอมไพล์เสร็จสมบูรณ์ คุณจะพบไฟล์ PHP ใหม่ของคุณในโฟลเดอร์ Release_TS การทดสอบ NMAKE ทำการทดสอบข้อผิดพลาดความจุสองเท่าใหม่เพื่อให้แน่ใจว่าทุกอย่างทำงานได้ตามปกติ ผลการทดสอบ NMAKE จะถูกส่งไปยังทีม QA ซึ่งต้องอาศัยพวกเขาในการปรับปรุง PHP ดังนั้นจึงอาจใช้เวลาสักครู่ในการทำงาน ซึ่งถือเป็นเรื่องใหญ่
ณ จุดนี้ คุณยังสามารถใช้ประโยชน์จากขั้นตอนเพิ่มเติมของการเรียกใช้สแน็ปอิน NMAKE ซึ่งจะสร้างไฟล์ ZIP และไบนารี่ที่คุณสามารถคัดลอกไปได้
ส่วนขยายการคอมไพล์
มีสองวิธีในการรวบรวมส่วนขยาย PHP: แบบคงที่และแบบไดนามิก ส่วนขยายที่คอมไพล์แบบคงที่จะถูกคอมไพล์เป็นไบนารี่ของ PHP ในขณะที่ส่วนขยายที่คอมไพล์แบบไดนามิกคือ DLL ที่แยกจากกันตัวหนึ่งซึ่งสามารถโหลดได้ในภายหลังผ่านไฟล์ php.ini โดยทั่วไปส่วนขยายจะถูกคอมไพล์เป็น DLL แม้ว่าจะมีข้อดีบางประการในการคอมไพล์แบบคงที่ และท้ายที่สุดก็ขึ้นอยู่กับความต้องการของคุณ
หากต้องการคอมไพล์ส่วนขยาย PHP บน Windows ให้แตกโฟลเดอร์ส่วนขยายซอร์สโค้ดลงในโฟลเดอร์ ext ของไดเร็กทอรีซอร์ส PHP ของคุณ จากนั้น กำหนดค่าสคริปต์ใหม่โดยการรัน buildconf --force และคอมไพล์ PHP ใหม่โดยใช้ตัวเลือกที่เหมาะสมเพื่อเปิดใช้งานส่วนขยาย
ตามตัวอย่าง เราจะรวบรวมส่วนขยาย AOP แบบคงที่ ดาวน์โหลดซอร์สโค้ดจาก PECL และแตกไฟล์ลงในโฟลเดอร์ ext. จากนั้นทำตามขั้นตอนเหล่านี้:
Cd C:\PHP-Dev\php5.4 buildconf --force กำหนดค่า --enable-aop nmake
ตัวเลือก --force, buildconf บังคับให้กู้คืนสคริปต์การกำหนดค่า จากนั้นให้รัน configuration --help แล้วคุณจะเห็นตัวเลือกในการเปิดใช้งานส่วนขยายใหม่ในเอาต์พุต ในกรณีนี้คือ --enable-AOP
เมื่อ nmake เสร็จสิ้น คุณจะมีไบนารี PHP ที่สร้างขึ้นใหม่พร้อม AOP
ส่วนขยายจะพร้อมใช้งานในรูปแบบ DLL แทนที่จะใช้งานใน PHP คุณสามารถทำตามขั้นตอนเดียวกับข้างต้น แต่การระบุ "shared" เนื่องจากค่าสำหรับการกำหนดค่าอนุญาตให้มีตัวเลือกได้
Buildconf --force กำหนดค่า --enable-aop=shared
ด้วยเหตุนี้ DLL จะอยู่ในโฟลเดอร์ Release_TS พร้อมกับไบนารี PHP เมื่อการคอมไพล์สิ้นสุดลง ในกรณีนี้ชื่อคือ php_aop.dll
ป.ล.
การคอมไพล์บน Windows ยังคงยุ่งยากเล็กน้อย โดยเฉพาะอย่างยิ่งเมื่อพูดถึงส่วนขยาย ความสามารถในการคอมไพล์ซอร์สโค้ดถือเป็นทักษะที่ดี โดยเฉพาะอย่างยิ่งหากคุณต้องการเปลี่ยน PHP ในภายหลัง
บทความนี้จัดทำขึ้นสำหรับคุณโดยทีมงานเว็บไซต์
บทความต้นฉบับ:
แปลโดย: วิคเตอร์ คลิม
นักพัฒนาเกือบทั้งหมดไม่ช้าก็เร็วต้องเผชิญกับความจำเป็นในการเรียกใช้หรือตรวจสอบโค้ดอย่างรวดเร็ว แต่ไม่ใช่ทุกคนที่รู้ว่าสำหรับงานง่าย ๆ ดังกล่าวนั้นไม่จำเป็นเลยที่จะต้องเรียกใช้ IDE บนเดสก์ท็อปจำนวนมากหรือคอมไพเลอร์แอปพลิเคชัน การใช้เครื่องมือออนไลน์ที่ช่วยให้คุณทำทุกอย่างเร็วขึ้นก็เพียงพอแล้ว: Ctrl+C, Ctrl+V, Run, whack - และผลลัพธ์ของโปรแกรมก็ปรากฏต่อหน้าต่อตาคุณเป็นสีแดงแล้ว
เราได้เลือกคอมไพเลอร์ออนไลน์ที่ดีที่สุด: บางอันค่อนข้างเป็นสากล ส่วนบางอันได้รับการปรับแต่งสำหรับงานที่กำหนดไว้อย่างเคร่งครัด ไม่ว่าในกรณีใดพวกเขาจะไม่ฟุ่มเฟือย
โคดิง
Koding.com ไม่ใช่คอมไพเลอร์ออนไลน์ในความหมายดั้งเดิม ผู้ใช้บริการแต่ละคนสามารถสร้างเครื่องเสมือนที่มีคุณสมบัติครบถ้วนหลายเครื่องที่ใช้ Ubuntu 14.04 ในระบบคลาวด์ ซึ่งพวกเขาสามารถทำทุกอย่างที่ต้องการได้ รวมถึงการคอมไพล์โค้ดด้วย ภาษายอดนิยมทั้งหมดได้รับการสนับสนุนโดยค่าเริ่มต้น แต่คุณสามารถเพิ่มภาษาของคุณเองได้อย่างง่ายดาย
นอกจากแผงควบคุมสำหรับเซิร์ฟเวอร์ของคุณแล้ว ยังมี IDE ที่สะดวกสบายและหน้าต่างเทอร์มินัลในอินเทอร์เฟซอีกด้วย Koding เป็นเครื่องมือที่เป็นสากลที่สุด ต่อไปเราจะดูตัวเลือกที่ง่ายกว่าและพิเศษยิ่งขึ้น
ไอเดียวัน
IdeOne คือเครื่องมือคอมไพเลอร์และการดีบักออนไลน์ที่ช่วยให้คุณสามารถรันโค้ดในภาษาการเขียนโปรแกรมมากกว่า 60 ภาษาและเวอร์ชันเฉพาะของภาษาเหล่านั้นได้โดยตรงในเบราว์เซอร์
สำหรับผู้ที่ไม่มีแฟน ผู้สร้างได้จัดเตรียมการคอมไพล์โค้ดเป็นภาษา Brainfuck
เจดูเดิ้ล
คอมไพเลอร์ออนไลน์อีกตัวที่รองรับหลายภาษา รวมถึงบางภาษาที่คุณจะไม่พบในคอมไพเลอร์ออนไลน์อื่นๆ อีกมากมาย คุณสมบัติที่ดีของ JDoodle คือความสามารถในการทำงานร่วมกัน - เพียงส่งลิงก์ไปยังเซสชันปัจจุบันของคุณและสร้างข้อบกพร่องด้วยความเร็วสองเท่า!
jsFiddle
อย่าปล่อยให้ชื่อหลอกคุณ jsFiddle ไม่ได้ถูกสร้างขึ้นมาเพื่อ JavaScript เท่านั้น โปรแกรมแก้ไขส่วนหน้าออนไลน์นี้ช่วยให้คุณสามารถทดสอบการผสมผสานระหว่าง JavaScript, HTML และ CSS แน่นอนว่ามีการรองรับเฟรมเวิร์กต่างๆ เช่น jQuery, Vue, React, TypeScript รวมถึงตัวประมวลผลล่วงหน้า CSS เช่น SCSS เพื่อความสะดวก คุณสามารถเลือกการเชื่อมโยงคีย์จากโปรแกรมแก้ไขที่คุณชื่นชอบได้ จริงอยู่ เฉพาะในกรณีที่โปรแกรมแก้ไขที่คุณชื่นชอบคือ Vim, Emacs หรือ Sublime Text
โค๊ดแพด
CodePad เป็นบริการที่เรียบง่ายซึ่งคุณสามารถจัดเก็บโค้ด แบ่งปัน และรันโค้ดพร้อมกับผลลัพธ์ของการดำเนินการที่ตามมา มีภาษาที่พบบ่อยที่สุดหลายภาษาให้เลือก แต่น่าเสียดายที่ไม่มีตัวเลือกล่ามหรือคอมไพเลอร์เวอร์ชันเฉพาะ
ข้อได้เปรียบหลักคือความเรียบง่ายและสะดวก: ไซต์จะทำงานได้อย่างรวดเร็วแม้จะมีการเชื่อมต่ออินเทอร์เน็ตที่ช้าก็ตาม มีการเชื่อมต่ออัตโนมัติของส่วนหัวมาตรฐาน รวมถึงการทำงานร่วมกับ Vim หรือ Emacs
ข้อเสียประการหนึ่งคือการขาดไวยากรณ์ที่เน้นโดยสิ้นเชิงเมื่อป้อนโค้ดลงในแบบฟอร์ม อย่างไรก็ตาม เมื่อดูการบันทึกที่บันทึกไว้แล้ว จะมีไฟแบ็คไลท์ปรากฏ
GCC ก็อดโบลต์
GCC GodBolt เป็นคอมไพเลอร์ C++ แบบโต้ตอบ ฉันเข้ามาที่คอลเลกชั่นนี้เพราะมีอินเทอร์เฟซที่เรียบง่าย รวมถึงการตั้งค่าจำนวนมาก รวมถึงตัวเลือกที่สามารถปรับได้ด้วยปุ่มต่างๆ
มีคอมไพเลอร์หลายเวอร์ชันให้เลือก รวมถึงเวอร์ชันล่าสุดด้วย หนึ่งในคุณสมบัติที่น่าสนใจคือการแปลโค้ดโปรแกรมเป็นภาษาแอสเซมบลีได้ทันที
PHP เป็นภาษาการเขียนโปรแกรมแบบตีความ แต่ละคำขอ ซอร์สโค้ดจะถูกวิเคราะห์และ "ดำเนินการ" แน่นอนว่าแนวทางนี้สะดวกมากในขั้นตอนการพัฒนาโครงการ แต่จะแนะนำขั้นตอนเพิ่มเติมในกระบวนการดำเนินการโค้ดที่ใช้งานจริง ดังนั้น การตีความซึ่งเมื่อมองแวบแรกคือจุดแข็งของ PHP จะทำให้เสียเวลาและทรัพยากร CPU เพิ่มขึ้น
ด้านล่างนี้เราจะพูดถึงคอมไพเลอร์ที่ให้คุณคอมไพล์โค้ด PHP ลงใน C++ และคอมไพล์เป็นโค้ดที่ปฏิบัติการได้ ดังนั้นแอปพลิเคชัน PHP จะถูกดำเนินการโดยโปรเซสเซอร์โดยตรง โดยไม่ผ่านล่าม
เรามาตรวจสอบว่าทุกอย่างดีในทางปฏิบัติหรือไม่
ล่ามทำงานอย่างไร
การตีความโค้ด PHP เกิดขึ้นในสองขั้นตอน:
- การแยกวิเคราะห์โค้ดและการสร้าง opcodes (Zend opcodes) - คำแนะนำที่ล่ามเข้าใจได้
- การดำเนินการของ opcodes
แม้ว่าระยะแรกจะช่วยในการปรับให้เหมาะสมได้ดี (โดยใช้แคช opcode) แต่ระยะที่สองค่อนข้างปิด - ล่ามจะเป็นตัวกลางระหว่างชุดคำสั่งและตัวประมวลผลที่ดำเนินการคำสั่งเหล่านั้นเสมอ หากไม่มีล่าม โปรเซสเซอร์จะไม่สามารถเข้าใจว่าต้องทำอย่างไรกับ opcodes
เพื่อกำจัดลิงค์ล่ามมีการคิดค้นคอมไพเลอร์ซึ่งได้รับความนิยมมากที่สุดและล่าสุดคือ HipHop จาก Facebook มาสัมผัสกันใกล้ๆ กันดีกว่า
ฮิปฮอป PHP
HipHop เขียนโดยนักพัฒนา Facebook และเป็นแอปพลิเคชั่นที่:- ปรับโค้ด PHP ให้เหมาะสม
- แปลงเป็น C ++
- สร้างเว็บเซิร์ฟเวอร์แบบมัลติเธรดจากแอปพลิเคชันของคุณที่ดำเนินการ
- คอมไพล์เป็นโค้ดปฏิบัติการโดยใช้ g++
ดังนั้นอินพุตคือโค้ด PHP เอาต์พุตคือเซิร์ฟเวอร์ ซึ่งส่วนหนึ่งเป็นฟังก์ชันการเขียน
มาดูกันว่า HipHop สามารถจัดการการคอมไพล์แอปพลิเคชันที่เขียนโดยใช้เฟรมเวิร์กเช่น Wordpress ได้อย่างไร
การคอมไพล์เวิร์ดเพรส
หลังจากติดตั้ง HipHop ในโฟลเดอร์ src/hphp/ เราจะได้ไฟล์ hphp ซึ่งเป็นคอมไพเลอร์ ก่อนการคอมไพล์เริ่มต้น ให้ตั้งค่าตัวแปรสภาพแวดล้อม:
Cd .. # ไปที่โฟลเดอร์ที่มี hiphop ส่งออก HPHP_HOME=`pwd` ส่งออก HPHP_LIB=`pwd`/bin ส่งออก CMAKE_PREFIX_PATH=`/bin/pwd`/../
และเดินหน้าต่อไป!
ดาวน์โหลด Wordpress และแตกไฟล์เก็บถาวร:
รับ http://wordpress.org/latest.tar.gz tar zxvf latest.tar.gz
คัดลอก wp-config-sample.php ไปยัง wp-config.php และระบุการตั้งค่าสำหรับการเชื่อมต่อกับฐานข้อมูล (ในการตั้งค่าโฮสต์เราระบุ 127.0.0.1 ไม่ใช่ localhost)
เพื่อการรวบรวมที่ประสบความสำเร็จคุณต้องแก้ไข Wordpress เล็กน้อย:
- เปิด wp-includes/js/tinymce/plugins/spellchecker/classes/SpellChecker.php และแทนที่: function &loopback(/* args.. */) ( return func_get_args(); ) ด้วยฟังก์ชัน &loopback(/* args.. */ ) ( $ret = func_get_args(); กลับ $ret; )
- ใน wp-includes/query.php แทนที่จะเป็น if (!isset($q["suppress_filters"])) $q["suppress_filters"] = false; ใส่ $q["suppress_filters"] = true;
เวิร์ดเพรสพร้อมแล้ว
Hiphop จำเป็นต้องระบุรายการไฟล์ที่เราจะคอมไพล์ - เราจะรับมันและบันทึกไว้ใน files.list:
หา. -ชื่อ "*.php" > files.list
ทุกอย่างพร้อมสำหรับการรวบรวม ดำเนินการต่อ:
$ HPHP_HOME/src/hphp/hphp --input-list=files.list -k 1 --log=3 --force=1 --cluster-count=50
หลังจากเสร็จสิ้นคำสั่ง ในโฟลเดอร์ชั่วคราว (ที่จุดเริ่มต้นของการคอมไพล์ hphp จะแสดงเส้นทางของมัน เช่น “/tmp/hphp_ptRgV1”) เราจะได้รับเว็บเซิร์ฟเวอร์ที่คอมไพล์แล้ว มาเริ่มกันเลย (หากมีสิ่งใดค้างอยู่บนพอร์ต 80 เช่น apache หรือ nginx คุณต้องหยุดมันก่อนเพื่อให้พอร์ตว่าง):
Sudo /tmp/hphp_6s0pzd/program -m เซิร์ฟเวอร์ -v "Server.SourceRoot=`pwd`" -v "Server.DefaultDocument=index.php" -c $HPHP_HOME/bin/mime.hdf
เอาล่ะ! เมื่อไปที่ http://localost เราจะเห็นบล็อก Wordpress ที่ใช้งานได้
ผลงาน
มาดูกันว่าจะมีการเพิ่มประสิทธิภาพหรือไม่เมื่อเทียบกับ WordPress เวอร์ชันที่ไม่ได้คอมไพล์ที่ทำงานบน apache2 ด้านล่างนี้เป็นกราฟของการพึ่งพาความเร็วในการสร้างเพจกับจำนวนผู้ใช้แบบขนาน
อย่างที่คุณเห็น ผลลัพธ์ที่ได้น่าตกใจ: บล็อกที่รวบรวมทำงานเร็วขึ้นโดยเฉลี่ย 6 เท่า! จำนวนคำขอเฉลี่ยที่ประมวลผลต่อวินาทีในเวอร์ชันที่ยังไม่ได้คอมไพล์คือ 9 และในเวอร์ชันที่คอมไพล์แล้วคือ 50! ฉันไม่รู้เกี่ยวกับคุณ แต่ผลลัพธ์เหล่านี้ทำให้ฉันประหลาดใจ ฉันไม่ได้คาดหวังว่าประสิทธิภาพจะเพิ่มขึ้นอย่างมาก
มาสรุปกัน
หลังจากผลลัพธ์อันน่าทึ่ง มีเพียงสิ่งเดียวเท่านั้นที่พูดได้ - พวกจาก Facebook ทำได้ดีมาก คอมไพเลอร์สร้างจรวดออกมาจากแอปพลิเคชันจริงๆ และถึงแม้ว่าจะต้องเตรียมแอปพลิเคชันก่อนทำการคอมไพล์ แต่ผลลัพธ์ก็คุ้มค่า
ในหัวข้อ:
หากคุณชอบโพสต์นี้ ให้คลิกที่ Google +1 - มันจะทำให้ฉันมีแรงบันดาลใจในการเขียนมากขึ้นและมันจะเป็นเรื่องที่น่ายินดี
ภาษาโปรแกรมมีสองประเภท: ตีความและเรียบเรียง PHP คืออะไร? เพื่อที่จะตอบคำถามนี้ เราต้องเข้าใจคำศัพท์
โปรแกรมที่แปลโค้ดที่เขียนด้วยภาษาโปรแกรมหนึ่งไปเป็นอีกภาษาหนึ่งเรียกว่านักแปล คอมไพเลอร์ก็เป็นนักแปลเช่นกัน โดยจะแปลโค้ดที่เขียนด้วยภาษาระดับสูงเป็นโค้ดเครื่อง กระบวนการคอมไพล์จะสร้างไฟล์ปฏิบัติการแบบไบนารีที่สามารถรันได้โดยไม่ต้องใช้คอมไพเลอร์
ล่ามเป็นประเภทที่แตกต่างไปจากเดิมอย่างสิ้นเชิง ล่ามไม่ได้แปลโค้ด แต่ดำเนินการ ล่ามวิเคราะห์โค้ดโปรแกรมและดำเนินการแต่ละบรรทัด ทุกครั้งที่คุณรันโค้ดดังกล่าว คุณต้องใช้ล่าม
ในแง่ของประสิทธิภาพล่ามนั้นด้อยกว่าคอมไพเลอร์อย่างมากเนื่องจากรหัสไบนารี่ดำเนินการเร็วกว่ามาก แต่ล่ามช่วยให้คุณสามารถควบคุมโปรแกรมได้อย่างเต็มที่ระหว่างการดำเนินการ
สำหรับ PHP นั้นไม่ใช่ทั้งคอมไพเลอร์หรือล่าม PHP เป็นการผสมผสานระหว่างคอมไพเลอร์และล่าม ลองทำความเข้าใจเรื่องนี้และดูว่า PHP ประมวลผลโค้ดอย่างไร
ลองดูที่ภาพ:
เราจะเห็นว่า PHP ประกอบด้วยสองบล็อกที่แทบจะเป็นอิสระจากกัน - นักแปลและล่าม ทำไมคุณต้องทำเช่นนี้? แน่นอนด้วยเหตุผลของความเร็ว
อินพุต PHP เป็นสคริปต์ มันแปล (แปล) ตรวจสอบไวยากรณ์เป็นไบต์โค้ดพิเศษ (การเป็นตัวแทนภายใน) จากนั้น PHP จะรันไบต์โค้ด (ไม่ใช่โค้ดของโปรแกรมเอง) แต่จะไม่สร้างไฟล์ปฏิบัติการ
Bytecode มีขนาดกะทัดรัดกว่าโค้ดโปรแกรมทั่วไปมาก ดังนั้นจึงง่าย (และเร็วกว่า) ในการตีความ (ดำเนินการ) ตัดสินด้วยตัวคุณเอง: การแยกวิเคราะห์จะดำเนินการเพียงครั้งเดียวในขั้นตอนการแปลและดำเนินการ "ผลิตภัณฑ์กึ่งสำเร็จรูป" - ไบต์โค้ดซึ่งสะดวกกว่ามากสำหรับวัตถุประสงค์เหล่านี้ ดังนั้น PHP จึงเป็นล่ามมากกว่าคอมไพเลอร์ “งานซ้อน” นี้จำเป็นสำหรับวัตถุประสงค์ดังต่อไปนี้
พิจารณาวง:
สำหรับ (i=0;i<10; i++) { Operator_1; Operator_2; Operator_3; ............ Operator_99; Operator_100; }
รอบนี้จะ "หมุน" 10 ครั้ง ในแต่ละรอบทั้งสิบนี้ ล่ามจะต้อง 100 บรรทัดของรหัส และจำเป็นต้องวิเคราะห์และรันโค้ด 10*100 = 1,000 บรรทัด! หากคุณแปลงลูปทั้งหมดเป็น bytecode เพียงครั้งเดียว จะต้องวิเคราะห์น้อยลง 10 เท่า! ซึ่งหมายความว่าสคริปต์จะทำงานเร็วขึ้น 10 เท่า!
ปรากฎว่า PHP เป็น
ขั้นตอนหลักของการทำงานของ PHP คือการตีความการนำเสนอภายในของโปรแกรมและการดำเนินการ เป็นขั้นตอนนี้ที่ใช้เวลามากที่สุดในสถานการณ์ร้ายแรง อย่างไรก็ตามการชะลอตัวไม่มีนัยสำคัญมากนัก
เป็นที่น่าจดจำว่า PHP เวอร์ชัน 3 เป็นล่ามที่ "บริสุทธิ์" และสคริปต์ PHP 4 เริ่มทำงานเร็วขึ้นมากเนื่องจาก PHP เวอร์ชัน 4 (และ PHP5) เป็นตัวแปลที่แปลความหมาย
ภาษา Perl ซึ่งมักเรียกว่าคอมไพเลอร์ทำงานในลักษณะเดียวกันทุกประการ - แปลข้อความของโปรแกรมเป็นการเป็นตัวแทนภายในจากนั้นใช้โค้ดผลลัพธ์ระหว่างการดำเนินการ ดังนั้น คุณสามารถพูดได้ว่า PHP เวอร์ชัน 4 เป็นคอมไพเลอร์พอๆ กับ Perl
ดังนั้นเราจึงถูกบังคับให้สรุปว่า PHP เป็นล่ามที่มีบล็อกการแปลในตัวที่ปรับการไหลของการตีความให้เหมาะสม
การใช้ล่าม (และด้วยเหตุนี้ PHP) จึงมีข้อดีที่ไม่อาจปฏิเสธได้:
- ไม่จำเป็นต้องกังวลเกี่ยวกับการเพิ่มหน่วยความจำที่จัดสรรให้ว่าง ไม่จำเป็นต้องปิดไฟล์เมื่อคุณทำงานกับไฟล์เหล่านั้นเสร็จแล้ว - ล่ามจะทำงานตามปกติทั้งหมดเนื่องจากโปรแกรมทำงานภายใต้การควบคุมที่เฝ้าระวัง
- ไม่จำเป็นต้องคำนึงถึงประเภทของตัวแปร และไม่จำเป็นต้องประกาศตัวแปรก่อนใช้งานครั้งแรก
- การดีบักโปรแกรมและการตรวจจับข้อผิดพลาดนั้นง่ายขึ้นมาก - ล่ามสามารถควบคุมกระบวนการนี้ได้อย่างสมบูรณ์
- ในบริบทของเว็บแอปพลิเคชันล่ามยังมีข้อได้เปรียบที่สำคัญมาก - ไม่มีอันตรายที่เซิร์ฟเวอร์จะ "ค้าง" หากโปรแกรมทำงานไม่ถูกต้อง
ยังมีข้อดีอื่นๆ อีกด้วย โดยทั่วไป การใช้ล่ามสามารถให้พลังแก่สคริปต์ตามที่ผู้ใช้เว็บคาดหวังจากพวกเขา
การลงโทษด้านประสิทธิภาพของ PHP นั้นสังเกตได้ชัดเจนในกรณีของการวนซ้ำขนาดใหญ่และซับซ้อน เมื่อประมวลผลบรรทัดจำนวนมาก ฯลฯ อย่างไรก็ตาม โปรดทราบว่านี่เป็นข้อเสียเปรียบเพียงอย่างเดียวของ PHP ซึ่งจะปรากฏน้อยลงเรื่อยๆ เมื่อมีการเปิดตัวโปรเซสเซอร์ที่ทรงพลังมากขึ้น จึงหายไปสิ้นไปในที่สุด
|
<<< Назад
(มีอะไรใหม่ใน PHP5?) |
เนื้อหา |
ไปข้างหน้า >>>
(เปลี่ยนเป็น PHP 5.3) |
| หากคุณมีคำถามอื่นๆ หรือบางสิ่งที่ไม่ชัดเจน - ยินดีต้อนรับสู่ของเรา | |
|
|
