การแสดงผลแบบเร่งความเร็วใน Chrome

โมเดลเลเยอร์

Tom Wiltzius
Tom Wiltzius

บทนำ

สำหรับนักพัฒนาเว็บส่วนใหญ่ โมเดลพื้นฐานของหน้าเว็บคือ 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 เป็นรูปภาพบนหน้าจอได้อย่างไร ในเชิงแนวคิดแล้ว การดำเนินการนี้จะทำสิ่งต่อไปนี้

  1. นำ DOM มาแบ่งออกเป็นเลเยอร์ต่างๆ
  2. วาดแต่ละเลเยอร์เหล่านี้แยกกันเป็นบิตแมปซอฟต์แวร์
  3. อัปโหลดไปยัง GPU เป็นพื้นผิว
  4. รวมเลเยอร์ต่างๆ เข้าด้วยกันเป็นรูปภาพหน้าจอสุดท้าย

ทั้งหมดนี้ต้องเกิดขึ้นในครั้งแรกที่ Chrome สร้างเฟรมของหน้าเว็บ แต่จะใช้ทางลัดสำหรับเฟรมในอนาคตได้ดังนี้

  1. หากพร็อพเพอร์ตี้ CSS บางอย่างมีการเปลี่ยนแปลง ก็ไม่จำเป็นต้องวาดใหม่ทั้งหมด Chrome สามารถจัดองค์ประกอบเลเยอร์ที่มีอยู่ซึ่งอยู่ใน GPU เป็นพื้นผิวได้อีกครั้ง แต่มีพร็อพเพอร์ตี้การจัดองค์ประกอบที่แตกต่างกัน (เช่น ในตำแหน่งที่แตกต่างกัน มีความทึบแสงต่างกัน เป็นต้น)
  2. หากส่วนหนึ่งของเลเยอร์ไม่ถูกต้อง ระบบจะวาดใหม่และอัปโหลดซ้ำ หากเนื้อหายังคงเหมือนเดิมแต่แอตทริบิวต์ที่ประกอบกันมีการเปลี่ยนแปลง (เช่น มีการแปลหรือความทึบแสงเปลี่ยนไป) Chrome จะปล่อยเนื้อหาไว้ใน GPU และจัดองค์ประกอบใหม่เพื่อสร้างเฟรมใหม่

ดังที่เห็นได้ชัดเจนแล้วว่าโมเดลการจัดองค์ประกอบตามเลเยอร์มีผลอย่างมากต่อประสิทธิภาพการแสดงผล การจัดองค์ประกอบมีค่าใช้จ่ายค่อนข้างต่ำเมื่อไม่จำเป็นต้องวาดอะไรเลย ดังนั้นการหลีกเลี่ยงการวาดเลเยอร์ซ้ำจึงเป็นเป้าหมายโดยรวมที่ดีเมื่อพยายามแก้ไขข้อบกพร่องของประสิทธิภาพการแสดงผล นักพัฒนาแอปที่เชี่ยวชาญจะดูรายการทริกเกอร์การจัดองค์ประกอบด้านบนและตระหนักว่าสามารถบังคับให้สร้างเลเยอร์ได้ง่ายๆ แต่โปรดระวังอย่าสร้างโดยไม่พิจารณาให้ดี เนื่องจากมีค่าใช้จ่าย โดยจะใช้หน่วยความจำใน RAM ของระบบและ GPU (ซึ่งมีจำกัดในอุปกรณ์เคลื่อนที่) และการมีจำนวนมากอาจทำให้เกิดค่าใช้จ่ายอื่นๆ ในตรรกะที่ติดตามว่ารายการใดมองเห็นได้ นอกจากนี้ เลเยอร์จำนวนมากยังอาจเพิ่มเวลาที่ใช้ในการแรสเตอร์ได้หากเลเยอร์มีขนาดใหญ่และซ้อนทับกันมากในจุดที่ก่อนหน้านี้ไม่ได้ซ้อนทับกัน ซึ่งนำไปสู่สิ่งที่บางครั้งเรียกว่า "การวาดทับ" ดังนั้นโปรดใช้ความรู้ของคุณอย่างชาญฉลาด

มีเท่านี้ โปรดติดตามบทความเพิ่มเติมอีก 2-3 บทความเกี่ยวกับผลกระทบในทางปฏิบัติของโมเดลเลเยอร์

แหล่งข้อมูลเพิ่มเติม