โมเดลเลเยอร์
บทนำ
สำหรับนักพัฒนาเว็บส่วนใหญ่ โมเดลพื้นฐานของหน้าเว็บคือ DOM การแสดงผลเป็นกระบวนการที่มักไม่ชัดเจนในการเปลี่ยนการแสดงผลของหน้าเว็บนี้ให้เป็นรูปภาพบนหน้าจอ เบราว์เซอร์ที่ทันสมัยได้เปลี่ยนวิธีการแสดงผลในช่วงไม่กี่ปีที่ผ่านมาเพื่อใช้ประโยชน์จากการ์ดกราฟิก ซึ่งมักเรียกกันอย่างคลุมเครือว่า "การเร่งฮาร์ดแวร์" เมื่อพูดถึงหน้าเว็บปกติ (เช่น ไม่ใช่ Canvas2D หรือ WebGL) คำนี้หมายความว่าอย่างไร บทความนี้จะอธิบายโมเดลพื้นฐานที่สนับสนุนการแสดงผลเนื้อหาเว็บที่เร่งด้วยฮาร์ดแวร์ใน Chrome
ข้อควรระวังที่สำคัญและมีมากมาย
เรากำลังพูดถึง WebKit และเจาะจงมากขึ้นคือพอร์ต Chromium ของ WebKit บทความนี้ครอบคลุมรายละเอียดการติดตั้งใช้งาน Chrome ไม่ใช่ฟีเจอร์ของแพลตฟอร์มเว็บ แพลตฟอร์มและมาตรฐานเว็บไม่ได้กำหนดรายละเอียดการใช้งานในระดับนี้ ดังนั้นจึงไม่มีการรับประกันว่าข้อมูลในบทความนี้จะใช้กับเบราว์เซอร์อื่นๆ ได้ แต่ความรู้เกี่ยวกับกลไกภายในก็ยังคงเป็นประโยชน์สำหรับการแก้ไขข้อบกพร่องและการปรับแต่งประสิทธิภาพขั้นสูง
นอกจากนี้ โปรดทราบว่าบทความนี้ทั้งหมดจะพูดถึงส่วนหลักของสถาปัตยกรรมการแสดงผลของ Chrome ที่มีการเปลี่ยนแปลงอย่างรวดเร็ว บทความนี้พยายามครอบคลุมเฉพาะสิ่งที่ไม่น่าจะเปลี่ยนแปลง แต่ก็ไม่รับประกันว่าทั้งหมดจะยังคงมีผลในอีก 6 เดือนข้างหน้า
คุณควรทราบว่า Chrome มีเส้นทางการแสดงผลที่แตกต่างกัน 2 เส้นทางมาเป็นระยะเวลาหนึ่งแล้ว ได้แก่ เส้นทางที่เร่งด้วยฮาร์ดแวร์และเส้นทางซอฟต์แวร์ที่เก่ากว่า ในขณะที่เขียนบทความนี้ หน้าเว็บทั้งหมดจะใช้เส้นทางการเร่งฮาร์ดแวร์ใน Windows, ChromeOS และ Chrome สำหรับ Android ใน Mac และ Linux เฉพาะหน้าเว็บที่ต้องมีการจัดองค์ประกอบสำหรับเนื้อหาบางส่วนเท่านั้นที่จะใช้เส้นทางที่เร่งความเร็ว (ดูข้อมูลเพิ่มเติมเกี่ยวกับสิ่งที่ต้องมีการจัดองค์ประกอบได้ที่ด้านล่าง) แต่ในเร็วๆ นี้ หน้าเว็บทั้งหมดจะใช้เส้นทางที่เร่งความเร็วด้วยเช่นกัน
สุดท้าย เราจะมาดูเบื้องหลังของเครื่องมือแสดงผลและฟีเจอร์ต่างๆ ที่มีผลอย่างมากต่อประสิทธิภาพ เมื่อพยายามปรับปรุงประสิทธิภาพของเว็บไซต์ของคุณเอง การทำความเข้าใจโมเดลเลเยอร์อาจเป็นประโยชน์ แต่ก็อาจทำให้เกิดปัญหาได้ง่ายเช่นกัน เลเยอร์เป็นโครงสร้างที่มีประโยชน์ แต่การสร้างเลเยอร์จำนวนมากอาจทำให้เกิดโอเวอร์เฮดตลอดทั้งสแต็กกราฟิก ถือว่าเราเตือนคุณแล้วนะ
จาก DOM ไปยังหน้าจอ
ขอแนะนำเลเยอร์
เมื่อโหลดและแยกวิเคราะห์หน้าเว็บแล้ว หน้าเว็บจะแสดงในเบราว์เซอร์เป็นโครงสร้างที่นักพัฒนาเว็บหลายคนคุ้นเคย นั่นคือ DOM อย่างไรก็ตาม เมื่อแสดงผลหน้าเว็บ เบราว์เซอร์จะมีการแสดงผลระดับกลางหลายรายการที่ไม่ได้แสดงต่อนักพัฒนาซอฟต์แวร์โดยตรง โครงสร้างที่สำคัญที่สุดคือเลเยอร์
ใน Chrome มีเลเยอร์หลายประเภท ได้แก่ RenderLayers ซึ่งรับผิดชอบซับทรีของ DOM และ GraphicsLayers ซึ่งรับผิดชอบซับทรีของ RenderLayers ส่วนหลังเป็นสิ่งที่น่าสนใจที่สุดสำหรับเราในที่นี้ เนื่องจาก GraphicsLayers คือสิ่งที่อัปโหลดไปยัง GPU เป็นพื้นผิว เราจะใช้คำว่า "เลเยอร์" จากนี้ไปเพื่อหมายถึง GraphicsLayer
คำอธิบายสั้นๆ เกี่ยวกับคำศัพท์ GPU: พื้นผิวคืออะไร ลองนึกภาพว่านี่เป็นรูปภาพบิตแมปที่ย้ายจากหน่วยความจำหลัก (เช่น RAM) ไปยังหน่วยความจำวิดีโอ (เช่น VRAM ใน GPU) เมื่ออยู่ใน GPU แล้ว คุณจะแมปพื้นผิวกับเรขาคณิตแบบเมชได้ โดยในวิดีโอเกมหรือโปรแกรม CAD จะใช้เทคนิคนี้เพื่อสร้าง "ผิว" ให้กับโมเดล 3 มิติแบบโครงกระดูก Chrome ใช้พื้นผิวเพื่อนำเนื้อหาหน้าเว็บเป็นส่วนๆ ไปไว้ใน GPU คุณสามารถแมปพื้นผิวกับตำแหน่งและการเปลี่ยนรูปแบบต่างๆ ได้อย่างประหยัดโดยใช้พื้นผิวกับ Mesh สี่เหลี่ยมผืนผ้าที่เรียบง่าย นี่คือวิธีการทำงานของ CSS 3 มิติ และยังเหมาะสำหรับการเลื่อนอย่างรวดเร็วด้วย แต่เราจะพูดถึงทั้ง 2 เรื่องนี้เพิ่มเติมในภายหลัง
มาดูตัวอย่าง 2-3 รายการเพื่ออธิบายแนวคิดเรื่องเลเยอร์กัน
เครื่องมือที่มีประโยชน์มากเมื่อศึกษาเลเยอร์ใน Chrome คือแฟล็ก "แสดงเส้นขอบเลเยอร์ที่ประกอบ" ในการตั้งค่า (เช่น ไอคอนฟันเฟืองเล็กๆ) ในเครื่องมือสำหรับนักพัฒนาเว็บ ภายใต้ส่วนหัว "การแสดงผล" ซึ่งจะไฮไลต์ตำแหน่งของเลเยอร์บนหน้าจออย่างง่ายๆ มาเปิดใช้กันเลย ภาพหน้าจอและตัวอย่างเหล่านี้ทั้งหมดนำมาจาก Chrome Canary เวอร์ชันล่าสุด ซึ่งก็คือ Chrome 27 ในขณะที่เขียนบทความนี้
รูปที่ 1: หน้าที่มีเลเยอร์เดียว
<!doctype html>
<html>
<body>
<div>I am a strange root.</div>
</body>
</html>
หน้านี้มีเพียงเลเยอร์เดียว ตารางกริดสีน้ำเงินแสดงถึงไทล์ ซึ่งคุณอาจมองว่าเป็นหน่วยย่อยของเลเยอร์ที่ Chrome ใช้เพื่ออัปโหลดส่วนต่างๆ ของเลเยอร์ขนาดใหญ่ไปยัง GPU ทีละส่วน ซึ่งไม่สำคัญมากนักในกรณีนี้
รูปที่ 2: องค์ประกอบในเลเยอร์ของตัวเอง
<!doctype html>
<html>
<body>
<div style="transform: rotateY(30deg) rotateX(-30deg); width: 200px;">
I am a strange root.
</div>
</body>
</html>
เมื่อใส่พร็อพเพอร์ตี้ CSS 3 มิติใน <div> ที่หมุนได้ เราจะเห็นลักษณะขององค์ประกอบเมื่อมีเลเยอร์ของตัวเอง โดยสังเกตเส้นขอบสีส้มซึ่งแสดงโครงร่างของเลเยอร์ในมุมมองนี้
เกณฑ์การสร้างเลเยอร์
มีอะไรอีกบ้างที่ควรมีเลเยอร์ของตัวเอง ฮิวริสติกของ Chrome ในส่วนนี้มีการพัฒนาไปเรื่อยๆ และจะยังคงพัฒนาต่อไป แต่ในปัจจุบัน สิ่งต่อไปนี้จะทริกเกอร์การสร้างเลเยอร์
- พร็อพเพอร์ตี้ CSS การเปลี่ยนรูปแบบ 3 มิติหรือมุมมอง
- องค์ประกอบ
<video>รายการที่ใช้การถอดรหัสวิดีโอแบบเร่งความเร็ว - องค์ประกอบ
<canvas>ที่มีบริบท 3 มิติ (WebGL) หรือบริบท 2 มิติแบบเร่งความเร็ว - ปลั๊กอินแบบผสม (เช่น Flash)
- องค์ประกอบที่มีภาพเคลื่อนไหว CSS สำหรับความทึบแสงหรือใช้การเปลี่ยนรูปแบบที่เคลื่อนไหว
- องค์ประกอบที่มีตัวกรอง CSS แบบเร่งความเร็ว
- องค์ประกอบมีองค์ประกอบสืบทอดที่มีเลเยอร์การจัดองค์ประกอบ (กล่าวคือ องค์ประกอบมีองค์ประกอบย่อยที่อยู่ในเลเยอร์ของตัวเอง)
- องค์ประกอบมีพี่น้องที่มีดัชนีลำดับ Z ต่ำกว่าซึ่งมีเลเยอร์การจัดองค์ประกอบ (กล่าวคือแสดงผลที่ด้านบนของเลเยอร์ที่จัดองค์ประกอบ)
ผลกระทบในทางปฏิบัติ: ภาพเคลื่อนไหว
นอกจากนี้ เรายังย้ายเลเยอร์ไปมาได้ด้วย ซึ่งทำให้เลเยอร์มีประโยชน์มากสำหรับการสร้างภาพเคลื่อนไหว
รูปที่ 3: เลเยอร์แบบเคลื่อนไหว
<!doctype html>
<html>
<head>
<style>
div {
animation-duration: 5s;
animation-name: slide;
animation-iteration-count: infinite;
animation-direction: alternate;
width: 200px;
height: 200px;
margin: 100px;
background-color: gray;
}
@keyframes slide {
from {
transform: rotate(0deg);
}
to {
transform: rotate(120deg);
}
}
</style>
</head>
<body>
<div>I am a strange root.</div>
</body>
</html>
อย่างที่กล่าวไปก่อนหน้านี้ เลเยอร์มีประโยชน์อย่างมากในการย้ายเนื้อหาเว็บแบบคงที่ ในกรณีพื้นฐาน Chrome จะแสดงเนื้อหาของเลเยอร์เป็นบิตแมปซอฟต์แวร์ก่อนที่จะอัปโหลดไปยัง GPU เป็นพื้นผิว หากเนื้อหานั้นไม่มีการเปลี่ยนแปลงในอนาคต ก็ไม่จำเป็นต้องวาดใหม่ ซึ่งเป็นสิ่งที่ดี เนื่องจากการวาดใหม่จะใช้เวลาที่สามารถนำไปใช้กับสิ่งอื่นๆ ได้ เช่น การเรียกใช้ JavaScript และหากการวาดใช้เวลานาน ก็จะทำให้เกิดการติดขัดหรือความล่าช้าในภาพเคลื่อนไหว
ตัวอย่างเช่น ดูมุมมองไทม์ไลน์ของเครื่องมือสำหรับนักพัฒนาเว็บนี้ จะเห็นว่าไม่มีการดำเนินการวาดขณะที่เลเยอร์นี้หมุนไปมา
ไม่ถูกต้อง การทาสีใหม่
แต่หากเนื้อหาของเลเยอร์มีการเปลี่ยนแปลง ก็จะต้องวาดใหม่
รูปที่ 4: การวาดเลเยอร์ใหม่
<!doctype html>
<html>
<head>
<style>
div {
animation-duration: 5s;
animation-name: slide;
animation-iteration-count: infinite;
animation-direction: alternate;
width: 200px;
height: 200px;
margin: 100px;
background-color: gray;
}
@keyframes slide {
from {
transform: rotate(0deg);
}
to {
transform: rotate(120deg);
}
}
</style>
</head>
<body>
<div id="foo">I am a strange root.</div>
<input id="paint" type="button" value="repaint">
<script>
var w = 200;
document.getElementById('paint').onclick = function() {
document.getElementById('foo').style.width = (w++) + 'px';
}
</script>
</body>
</html>
ทุกครั้งที่มีการคลิกองค์ประกอบอินพุต องค์ประกอบที่หมุนจะกว้างขึ้น 1 พิกเซล ซึ่งจะทำให้เกิดการจัดวางและการวาดองค์ประกอบทั้งหมดใหม่ ซึ่งในกรณีนี้คือทั้งเลเยอร์
วิธีที่ดีในการดูว่ามีการวาดอะไรบ้างคือการใช้เครื่องมือ "แสดงสี่เหลี่ยมผืนผ้าที่วาด" ในเครื่องมือสำหรับนักพัฒนาเว็บ ซึ่งอยู่ใต้ส่วนหัว "การแสดงผล" ของการตั้งค่าเครื่องมือสำหรับนักพัฒนาเว็บด้วย หลังจากเปิดแล้ว ให้สังเกตว่าองค์ประกอบที่เคลื่อนไหวและปุ่มจะกะพริบเป็นสีแดงเมื่อคลิกปุ่ม
เหตุการณ์การแสดงผลจะปรากฏในไทม์ไลน์ของเครื่องมือสำหรับนักพัฒนาเว็บด้วย ผู้อ่านที่ตาไวอาจสังเกตเห็นว่ามีเหตุการณ์การวาด 2 เหตุการณ์ ได้แก่ เหตุการณ์หนึ่งสำหรับเลเยอร์ และอีกเหตุการณ์หนึ่งสำหรับตัวปุ่มเอง ซึ่งจะได้รับการวาดใหม่เมื่อเปลี่ยนสถานะเป็น/จากสถานะที่ถูกกด
โปรดทราบว่า Chrome ไม่จำเป็นต้องวาดทั้งเลเยอร์ใหม่เสมอไป แต่จะพยายามวาดเฉพาะส่วนของ DOM ที่ไม่ถูกต้องใหม่ ในกรณีนี้ องค์ประกอบ DOM ที่เราแก้ไขคือขนาดของทั้งเลเยอร์ แต่ในกรณีอื่นๆ อีกหลายกรณี จะมีองค์ประกอบ DOM จำนวนมากในเลเยอร์
คำถามถัดไปที่ชัดเจนคืออะไรเป็นสาเหตุของการทำให้เป็นโมฆะและบังคับให้มีการวาดใหม่ คำถามนี้ตอบได้ยากอย่างละเอียดถี่ถ้วนเนื่องจากมีกรณีพิเศษจำนวนมากที่อาจทำให้เกิดการลบล้างได้ สาเหตุที่พบบ่อยที่สุดคือการทำให้ DOM สกปรกโดยการจัดการสไตล์ CSS หรือทำให้เกิดการจัดเลย์เอาต์ใหม่ Tony Gentilcore มีบล็อกโพสต์ที่ยอดเยี่ยมเกี่ยวกับสาเหตุที่ทำให้เกิดการจัดเลย์เอาต์ใหม่ และ Stoyan Stefanov มีบทความที่ครอบคลุมการวาดโดยละเอียด (แต่จบลงด้วยการวาดเท่านั้น ไม่ใช่การจัดองค์ประกอบที่ซับซ้อนนี้)
วิธีที่ดีที่สุดในการตรวจสอบว่าการดำเนินการนี้ส่งผลต่อสิ่งที่คุณกำลังทำอยู่หรือไม่คือการใช้เครื่องมือ Dev Tools Timeline และ Show Paint Rects เพื่อดูว่าคุณกำลังวาดใหม่เมื่อคุณไม่ต้องการหรือไม่ จากนั้นลองระบุตำแหน่งที่คุณทำให้ DOM สกปรกก่อนการจัดวาง/วาดใหม่นั้น หากหลีกเลี่ยงการวาดไม่ได้แต่ดูเหมือนว่าจะใช้เวลานานเกินควร โปรดอ่านบทความของ Eberhard Gräther เกี่ยวกับโหมดการวาดต่อเนื่องในเครื่องมือสำหรับนักพัฒนาเว็บ
การรวมข้อมูลเข้าด้วยกัน: DOM ไปยังหน้าจอ
แล้ว Chrome เปลี่ยน DOM เป็นรูปภาพบนหน้าจอได้อย่างไร ในเชิงแนวคิดแล้ว การดำเนินการนี้จะทำสิ่งต่อไปนี้
- นำ DOM มาแบ่งออกเป็นเลเยอร์ต่างๆ
- วาดแต่ละเลเยอร์เหล่านี้แยกกันเป็นบิตแมปซอฟต์แวร์
- อัปโหลดไปยัง GPU เป็นพื้นผิว
- รวมเลเยอร์ต่างๆ เข้าด้วยกันเป็นรูปภาพหน้าจอสุดท้าย
ทั้งหมดนี้ต้องเกิดขึ้นในครั้งแรกที่ Chrome สร้างเฟรมของหน้าเว็บ แต่จะใช้ทางลัดสำหรับเฟรมในอนาคตได้ดังนี้
- หากพร็อพเพอร์ตี้ CSS บางอย่างมีการเปลี่ยนแปลง ก็ไม่จำเป็นต้องวาดใหม่ทั้งหมด Chrome สามารถจัดองค์ประกอบเลเยอร์ที่มีอยู่ซึ่งอยู่ใน GPU เป็นพื้นผิวได้อีกครั้ง แต่มีพร็อพเพอร์ตี้การจัดองค์ประกอบที่แตกต่างกัน (เช่น ในตำแหน่งที่แตกต่างกัน มีความทึบแสงต่างกัน เป็นต้น)
- หากส่วนหนึ่งของเลเยอร์ไม่ถูกต้อง ระบบจะวาดใหม่และอัปโหลดซ้ำ หากเนื้อหายังคงเหมือนเดิมแต่แอตทริบิวต์ที่ประกอบกันมีการเปลี่ยนแปลง (เช่น มีการแปลหรือความทึบแสงเปลี่ยนไป) Chrome จะปล่อยเนื้อหาไว้ใน GPU และจัดองค์ประกอบใหม่เพื่อสร้างเฟรมใหม่
ดังที่เห็นได้ชัดเจนแล้วว่าโมเดลการจัดองค์ประกอบตามเลเยอร์มีผลอย่างมากต่อประสิทธิภาพการแสดงผล การจัดองค์ประกอบมีค่าใช้จ่ายค่อนข้างต่ำเมื่อไม่จำเป็นต้องวาดอะไรเลย ดังนั้นการหลีกเลี่ยงการวาดเลเยอร์ซ้ำจึงเป็นเป้าหมายโดยรวมที่ดีเมื่อพยายามแก้ไขข้อบกพร่องของประสิทธิภาพการแสดงผล นักพัฒนาแอปที่เชี่ยวชาญจะดูรายการทริกเกอร์การจัดองค์ประกอบด้านบนและตระหนักว่าสามารถบังคับให้สร้างเลเยอร์ได้ง่ายๆ แต่โปรดระวังอย่าสร้างโดยไม่พิจารณาให้ดี เนื่องจากมีค่าใช้จ่าย โดยจะใช้หน่วยความจำใน RAM ของระบบและ GPU (ซึ่งมีจำกัดในอุปกรณ์เคลื่อนที่) และการมีจำนวนมากอาจทำให้เกิดค่าใช้จ่ายอื่นๆ ในตรรกะที่ติดตามว่ารายการใดมองเห็นได้ นอกจากนี้ เลเยอร์จำนวนมากยังอาจเพิ่มเวลาที่ใช้ในการแรสเตอร์ได้หากเลเยอร์มีขนาดใหญ่และซ้อนทับกันมากในจุดที่ก่อนหน้านี้ไม่ได้ซ้อนทับกัน ซึ่งนำไปสู่สิ่งที่บางครั้งเรียกว่า "การวาดทับ" ดังนั้นโปรดใช้ความรู้ของคุณอย่างชาญฉลาด
มีเท่านี้ โปรดติดตามบทความเพิ่มเติมอีก 2-3 บทความเกี่ยวกับผลกระทบในทางปฏิบัติของโมเดลเลเยอร์