รับการแจ้งเตือนเกี่ยวกับแรงดันในการประมวลผลของระบบ
Compute Pressure API เสนอสถานะระดับสูงที่แสดงถึงแรงกดของระบบ ทำให้การติดตั้งใช้งานได้ใช้เมตริกฮาร์ดแวร์ที่เกี่ยวข้อง เพื่อให้มั่นใจว่าผู้ใช้จะสามารถใช้ประโยชน์จากพลังการประมวลผลที่มี ตราบใดที่ระบบไม่อยู่ใต้ความเครียดที่จัดการไม่ได้
สถานะปัจจุบัน
| ขั้นตอน | สถานะ |
|---|---|
| 1. สร้างข้อความอธิบาย | เสร็จสมบูรณ์ |
| 2. สร้างฉบับร่างเริ่มต้นของข้อกำหนด | เสร็จสมบูรณ์ |
| 3. รวบรวมความคิดเห็นและทำซ้ำเกี่ยวกับการออกแบบ | กำลังดำเนินการ |
| 4. ช่วงทดลองใช้จากต้นทาง | เสร็จสมบูรณ์ |
| 5. เปิดตัว | เสร็จสมบูรณ์ (Chrome 125) |
ลองใช้ Compute Pressure API
หากต้องการทดสอบกับ Compute Pressure API ภายในเครื่อง โปรดอ่านหน้านี้
ลงทะเบียนช่วงทดลองใช้จากต้นทาง
Compute Pressure API พร้อมให้ใช้งานในรูปแบบช่วงทดลองใช้จากต้นทางใน Chrome 115 ซึ่งคาดว่าจะลงท้ายด้วย Chrome 123 (29 พฤษภาคม 2024) ลงทะเบียนทดลองใช้จากต้นทาง
กรณีการใช้งาน
กรณีการใช้งานหลักที่ Compute Pressure API ปัจจุบันเพิ่มประสิทธิภาพ ได้แก่ การประชุมทางวิดีโอและวิดีโอเกม
แอปพลิเคชันแบบเรียลไทม์ที่ได้รับความนิยมเหล่านี้จัดเป็นประเภท soft กล่าวคือ คุณภาพของบริการจะลดลงหากมีการใช้งานระบบนอกเหนือบางรัฐ แต่ไม่ส่งผลให้ระบบล้มเหลวทั้งหมด แอปพลิเคชันเรียลไทม์แบบซอฟต์เหล่านี้ได้ประโยชน์อย่างมากจากความสามารถในการปรับภาระงานตามการใช้งานหรือแรงกดของ 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(): ระบบจะเรียกโค้ดเรียกกลับด้วยอาร์เรย์ของออบเจ็กต์ 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.
}
สร้างเครื่องสังเกตความดัน
สร้างเครื่องสังเกตความดันโดยเรียกใช้ตัวสร้างด้วยฟังก์ชันเรียกกลับให้เรียกใช้ทุกครั้งที่มีการอัปเดตแรงดัน
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 ในช่องคอมโพเนนต์