รับข้อมูลเกี่ยวกับภาระงานของระบบประมวลผล
Compute Pressure API แสดงสถานะระดับสูงที่แสดงถึงภาระของระบบ ซึ่งช่วยให้การติดตั้งใช้งานใช้เมตริกฮาร์ดแวร์พื้นฐานที่เหมาะสมเพื่อให้ผู้ใช้ใช้ประโยชน์จากกำลังประมวลผลทั้งหมดที่มีได้ตราบใดที่ระบบไม่อยู่ภายใต้ความเครียดที่จัดการไม่ได้
สถานะปัจจุบัน
| ขั้นตอน | สถานะ |
|---|---|
| 1. สร้างคําอธิบาย | เสร็จสมบูรณ์ |
| 2. สร้างฉบับร่างแรกของข้อกําหนด | เสร็จสมบูรณ์ |
| 3. รวบรวมความคิดเห็นและปรับปรุงการออกแบบ | กำลังดำเนินการ |
| 4. ช่วงทดลองใช้จากต้นทาง | เสร็จสมบูรณ์ |
| 5. เปิดตัว | เสร็จสมบูรณ์ (Chrome 125) |
ลองใช้ Compute Pressure API
หากต้องการทดสอบ Compute Pressure API ในเครื่อง ให้อ่านหน้านี้
ลงทะเบียนทดลองใช้จากต้นทาง
ตั้งแต่ Chrome 115 เป็นต้นไป Compute Pressure API จะพร้อมใช้งานเป็นช่วงทดลองใช้จากต้นทาง โดยคาดว่าจะสิ้นสุดใน Chrome 123 (29 พฤษภาคม 2024) ลงทะเบียนช่วงทดลองใช้จากต้นทาง
กรณีการใช้งาน
กรณีการใช้งานหลักที่ Compute Pressure API ปัจจุบันปรับปรุงให้ดีขึ้นคือการประชุมทางวิดีโอและวิดีโอเกม
แอปพลิเคชันเรียลไทม์ยอดนิยมเหล่านี้จัดอยู่ในประเภทซอฟต์ กล่าวคือ คุณภาพของบริการจะลดลงหากระบบทำงานเกินสถานะหนึ่งๆ แต่จะไม่ทําให้ระบบใช้งานไม่ได้ทั้งหมด แอปพลิเคชันแบบเรียลไทม์แบบอ่อนเหล่านี้ได้รับประโยชน์อย่างมากจากการปรับตัวตามภาระงานตามการบริโภคหรือแรงกดดันของ CPU
โดยเฉพาะอย่างยิ่ง API เวอร์ชันแรกนี้มีจุดประสงค์เพื่อเปิดใช้การตัดสินใจในการปรับเปลี่ยนต่อไปนี้
การประชุมทางวิดีโอ
- ปรับจำนวนฟีดวิดีโอที่แสดงพร้อมกันระหว่างการโทรที่มีผู้เข้าร่วมหลายคน
- ลดคุณภาพการประมวลผลวิดีโอ (ความละเอียดของวิดีโอ เฟรมต่อวินาที)
- ข้ามการประมวลผลวิดีโอที่ไม่จำเป็น เช่น ฟิลเตอร์กล้องบางรายการ
- ปิดใช้การประมวลผลเสียงที่ไม่จำเป็น เช่น การลดเสียงรบกวน WebRTC
- หมุนปุ่มคุณภาพเทียบกับความเร็วและขนาดเทียบกับความเร็วไปที่ "ความเร็ว" ในการเข้ารหัสวิดีโอและเสียง (ใน WebRTC, WebCodecs หรือการเข้ารหัสซอฟต์แวร์)
วิดีโอเกม
- ใช้ชิ้นงานคุณภาพต่ำในการประกอบวิดีโอ (โมเดล 3 มิติ พื้นผิว ชิดเดอร์) และเสียง (เสียงพูด เสียงประกอบ) ของเกม
- ปิดใช้เอฟเฟกต์ที่ทำให้รายละเอียดที่ไม่จำเป็นดูไม่สมจริง (น้ำ ผ้า ภาพเคลื่อนไหวของไฟ ความสว่างของผิว เอฟเฟกต์แสงสะท้อน หรือการจำลองทางกายภาพที่ไม่ส่งผลต่อเกมเพลย์)
- ปรับแต่งปุ่มคุณภาพเทียบกับความเร็วในเครื่องมือแสดงผลของเกม (คุณภาพเงา การปรับแต่งพื้นผิว ระยะมอง)
ในทางเทคนิคแล้ว การดำเนินการเหล่านี้ทำได้โดยการทำความเข้าใจความร้อน (เช่น ระบบมีการระบายความร้อนแบบพาสซีฟหรือไม่) และสถานะการกดดันของ CPU สำหรับเธรดหลักและเวิร์กเกอร์ที่เว็บไซต์ใช้ สถานะความร้อนของระบบเป็นสถานะส่วนกลางและอาจได้รับผลกระทบจากแอปและเว็บไซต์อื่นๆ นอกเหนือจากเว็บไซต์ที่สังเกตการณ์
อินเทอร์เฟซ
Compute Pressure API สามารถเรียกใช้ได้ในบริบทต่อไปนี้
- หน้าต่างหรือเทรดหลัก
- ผู้ปฏิบัติงานเฉพาะทาง
- ผู้ปฏิบัติงานที่แชร์
Compute Pressure API จะกําหนดอินเทอร์เฟซใหม่ 2 รายการ
PressureObserver: ออบเจ็กต์สำหรับสังเกตการณ์ภาระงานการประมวลผลของแหล่งที่มาจำนวนเท่าใดก็ได้ในช่วงเวลาที่เลือกไว้ล่วงหน้า การทำซ้ำครั้งแรกใน Chromium จะแสดง "cpu" เป็น source ดูรายละเอียดเพิ่มเติมได้ที่ส่วนพารามิเตอร์ ผู้สังเกตการณ์แต่ละรายสามารถสังเกตแนวโน้มการเปลี่ยนแปลงความดันในระบบแบบไม่พร้อมกัน
PressureRecord: อธิบายแนวโน้มความดัน ณ ช่วงเวลาหนึ่งๆ ของการเปลี่ยนผ่าน ออบเจ็กต์ประเภทนี้จะได้รับได้ 2 วิธีเท่านั้น ได้แก่ ใช้เป็นอินพุตสำหรับคอลแบ็ก PressureObserver หรือเรียกใช้เมธอด takeRecords() ในอินสแตนซ์ PressureObserver
PressureObserver
เมื่อสร้างออบเจ็กต์ PressureObserver ระบบจะกําหนดค่าให้ตรวจสอบแรงดันของแหล่งที่มาที่รองรับในช่วงเวลาที่เลือก แหล่งที่มาที่รองรับจะสังเกตหรือไม่สังเกตได้ทีละรายการทุกเมื่อตลอดอายุการใช้งานของออบเจ็กต์ PressureObserver คุณจะเปลี่ยนช่วงเวลาของตัวอย่างไม่ได้หลังจากสร้างออบเจ็กต์แล้ว
ผู้ผลิต
PressureObserver(callback): สร้างออบเจ็กต์ PressureObserver ใหม่ซึ่งจะเรียกใช้ฟังก์ชันการเรียกกลับที่ระบุเมื่อตรวจพบว่ามีการเปลี่ยนแปลงค่าของแหล่งที่มาที่สังเกต
เครื่องมือสร้างจะใช้ฟังก์ชัน callback ที่ต้องระบุ
การติดต่อกลับ
callback(): ระบบจะเรียกใช้การเรียกกลับพร้อมอาร์เรย์ของPressureRecord
ออบเจ็กต์ที่ยังไม่อ่าน
เมธอด
PressureObserver.observe(source, options): บอก "PressureObserver" ว่าแหล่งที่มาใดที่จะสังเกตและ options (ไม่บังคับ) เป็นพารามิเตอร์
ตัวเลือก
PressureObserverOptions: มีช่วงเวลาของตัวอย่าง sampleInterval เป็นมิลลิวินาทีที่ผู้ใช้ขอการอัปเดต
PressureObserver.unobserve(source): บอก "PressureObserver" ให้หยุดสังเกตแหล่งที่มา
PressureObserver.disconnect(): บอก "PressureObserver" ให้หยุดสังเกตแหล่งที่มาทั้งหมด
PressureObserver.takeRecords(): แสดงผลลําดับระเบียนนับตั้งแต่การเรียกใช้การเรียกกลับครั้งล่าสุด
static PressureObserver.knownSources() (อ่านอย่างเดียว): แสดงประเภทแหล่งที่มาที่รู้จักของ User Agent ตามลําดับตัวอักษร
พารามิเตอร์
source: แหล่งที่มาที่จะสังเกต เช่น "cpu" ต้องเป็นประเภทแหล่งที่มาที่รองรับ
ในเวอร์ชันปัจจุบันของ Compute Pressure ระบบรองรับเฉพาะ "cpu" เท่านั้น
PressureRecord
อินเทอร์เฟซ PressureRecord ของ Compute Pressure API จะอธิบายแนวโน้มของแรงกดดันของแหล่งที่มา ณ ช่วงเวลาหนึ่งๆ ของการเปลี่ยนผ่าน
พร็อพเพอร์ตี้ของอินสแตนซ์
PressureRecord.source (อ่านอย่างเดียว): แสดงสตริงที่แสดงแหล่งที่มาของต้นทางที่ระเบียนนั้นมาจาก
PressureRecord.state (อ่านอย่างเดียว): แสดงผลสตริงที่แสดงสถานะแรงดันที่บันทึกไว้
PressureRecord.time (อ่านอย่างเดียว): แสดงผลตัวเลขที่แสดงการประทับเวลาความละเอียดสูง
ตัวอย่าง
ส่วนต่อไปนี้แสดงตัวอย่างการใช้งาน
ตรวจสอบการรองรับ API
if ('PressureObserver' in globalThis) {
// The Compute Pressure API is supported.
}
สร้างเครื่องมือวัดความดัน
สร้างเครื่องมือตรวจสอบความดันโดยเรียกใช้คอนสตรัคเตอร์ด้วยฟังก์ชัน Callback เพื่อเรียกใช้ทุกครั้งที่มีการอัปเดตความดัน
const observer = new PressureObserver((records) => {
/* ... */
});
การใช้เครื่องมือวัดความดัน
การเริ่มเครื่องมือวัดความดันทำได้เพียงวิธีเดียว สําหรับการเรียกแหล่งที่มาแต่ละครั้ง
observer.observe(source)
observer.observe("cpu" { sampleInterval: 2_000 });
ในตัวอย่างนี้ "cpu" คือแหล่งที่มาของแรงดันที่เราสนใจ ซึ่งตอนนี้เป็นช่องทางเดียวที่ใช้ได้ ในอนาคตอาจมีแหล่งที่มาอื่นๆ เช่น "gpu", "power" หรือ "thermals"
ช่วงเวลาตัวอย่าง sampleInterval เท่ากับ 2,000 มิลลิวินาที หมายความว่าจะมีการอัปเดตทุก 2 วินาทีเป็นอย่างช้าที่สุด
หากระบบไม่สามารถแสดงตัวอย่างตามช่วงเวลาที่ขอ ระบบจะแสดงตัวอย่างในช่วงเวลาที่เหมาะสมที่สุดที่มีอยู่ เช่น หากมีการขอช่วงเวลา 2, 000 มิลลิวินาที แต่ระบบให้ข้อมูลตัวอย่างได้สูงสุด 1, 000 มิลลิวินาที ระบบจะเลือก 1, 000 มิลลิวินาที
หากต้องการหยุดสังเกตแหล่งที่มา ให้ใช้เมธอด unobserve() ดังตัวอย่างต่อไปนี้
observer.unobserve('cpu');
หากต้องการยกเลิกการสังเกตแหล่งที่มาทั้งหมดพร้อมกัน ให้ใช้เมธอด disconnect() ดังตัวอย่างต่อไปนี้
observer.disconnect();
เรียกข้อมูลบันทึกความดัน
คุณสามารถเรียกข้อมูลบันทึกความดันด้วยฟังก์ชันการเรียกกลับ ซึ่งจะเรียกใช้ทุกครั้งที่มีการเปลี่ยนแปลงในสถานะความดัน
function callback(records) {
const lastRecord = records[records.length - 1];
console.log(`Current pressure ${lastRecord.state}`);
if (lastRecord.state === 'critical') {
// Reduce workers load by 4.
} else if (lastRecord.state === 'serious') {
// Reduce workers load by 2.
} else {
// Do not reduce.
}
}
const observer = new PressureObserver(callback);
await observer.observe('cpu', { sampleInterval: 1_000 });
นอกจากนี้ ผู้ใช้ยังบังคับให้อ่าน PressureRecord ได้โดยเรียกใช้เมธอด
takeRecords()
เมธอด takeRecords() ของอินเทอร์เฟซ PressureObserver จะแสดงผลอาร์เรย์ของออบเจ็กต์ PressureRecords ที่เก็บไว้ในเครื่องมือวัดความดัน โดยล้างข้อมูลออก
Use Case ที่พบบ่อยที่สุดสำหรับการดำเนินการนี้คือดึงข้อมูลบันทึกความดันที่รอดำเนินการทั้งหมดซึ่งฟังก์ชันการเรียกกลับของผู้สังเกตการณ์ยังไม่ได้ประมวลผลทันทีก่อนที่จะยกเลิกการเชื่อมต่อผู้สังเกตการณ์ เพื่อให้ระบบประมวลผลระเบียนที่รอดำเนินการเมื่อปิดผู้สังเกตการณ์
การเรียกใช้เมธอดนี้จะล้างรายการระเบียนที่รอดําเนินการ ระบบจึงจะไม่เรียกใช้การเรียกกลับ
const observer = new PressureObserver((records) => {
/* Do something with records. */
});
await observer.observe('cpu', { sampleInterval: 1_000 });
setTimeout(() => {
// Forced records reading.
const records = observer.takeRecords();
observer.disconnect();
// Do something with last records if any.
}, 2000);
แชร์ความคิดเห็น
มีสิ่งใดเกี่ยวกับ API ที่ไม่ทำงานตามที่คาดไว้ไหม คุณเห็นเมธอดหรือพร็อพเพอร์ตี้ที่ขาดหายไปสําหรับการใช้งาน API ไหม แจ้งปัญหาเกี่ยวกับข้อกำหนดหรือแสดงความคิดเห็นในปัญหาที่มีอยู่ในที่เก็บ GitHub ที่เกี่ยวข้อง
รายงานปัญหาเกี่ยวกับการติดตั้งใช้งาน
หากพบข้อบกพร่องในการใช้งาน Chromium หรือการใช้งานแตกต่างจากข้อกําหนดหรือไม่ รายงานข้อบกพร่องที่ new.crbug.com โดยระบุรายละเอียดให้มากที่สุด วิธีการจำลองข้อบกพร่องซ้ำ และป้อน Blink>PerformanceAPIs>ComputePressure ในช่องคอมโพเนนต์