รับการแจ้งเตือนเกี่ยวกับแรงดันในการประมวลผลของระบบ
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 ปรับปรุงในปัจจุบัน ได้แก่ การประชุมทางวิดีโอและวิดีโอเกม
แอปพลิเคชันแบบเรียลไทม์ที่ได้รับความนิยมเหล่านี้จัดเป็นประเภท 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, options): สร้างออบเจ็กต์ PressureObserver ใหม่ซึ่งจะเรียกใช้ฟังก์ชันเรียกกลับที่ระบุเมื่อตรวจพบว่ามีการเปลี่ยนแปลงค่าของแหล่งที่มาที่พบ
ตัวสร้างจะใช้ฟังก์ชันการเรียกกลับที่จำเป็นและตัวเลือกที่ไม่บังคับในรูปแบบพารามิเตอร์
การติดต่อกลับ
callback(): ระบบจะเรียกโค้ดเรียกกลับด้วยอาร์เรย์ของออบเจ็กต์ PressureRecord ที่ยังไม่อ่าน
ตัวเลือก
PressureObserverOptions: มีช่วงการสุ่มตัวอย่าง sampleInterval เป็นมิลลิวินาทีที่ผู้ใช้ขออัปเดต
วิธีการ
PressureObserver.observe(source): บอก "PressureObserver" ให้สังเกตแหล่งที่มา
PressureObserver.unobserve(source): บอก "PressureObserver" ให้หยุดสังเกตแหล่งที่มา
PressureObserver.disconnect(): บอก "PressureObserver" ให้หยุดสังเกตแหล่งที่มาทั้งหมด
PressureObserver.takeRecords(): แสดงผลลำดับระเบียน ตั้งแต่การเรียกใช้โค้ดเรียกกลับครั้งล่าสุด
static PressureObserver.supportedSources() (อ่านอย่างเดียว): แสดงผลประเภทแหล่งที่มาที่ฮาร์ดแวร์รองรับ
พารามิเตอร์
source: แหล่งที่มาที่ต้องการสังเกต เช่น "cpu" ซึ่งต้องเป็นประเภทแหล่งที่มาที่รองรับ
Compute Pressure เวอร์ชันปัจจุบันรองรับเฉพาะ "cpu"
PressureRecord
อินเทอร์เฟซ PressureRecord ของ Compute Pressure API อธิบายแนวโน้มแรงกดของแหล่งที่มา ณ ช่วงเวลาที่เฉพาะเจาะจงของการเปลี่ยน
พร็อพเพอร์ตี้ของอินสแตนซ์
PressureRecord.source (อ่านอย่างเดียว): แสดงผลสตริงที่แสดงถึงแหล่งที่มาของต้นทางที่ระเบียนมา
PressureRecord.state (อ่านอย่างเดียว): แสดงผลสตริงที่แสดงสถานะความดันที่บันทึกไว้
PressureRecord.time (อ่านอย่างเดียว): แสดงผลตัวเลขที่แสดงถึงการประทับเวลาที่มีความละเอียดสูง
ตัวอย่าง
มีการรองรับ Compute Pressure API ไหม
if ('PressureObserver' in globalThis) {
// The Compute Pressure API is supported.
}
การสร้างอุปกรณ์สังเกตความดัน
สร้างเครื่องมือสังเกตความดันโดยเรียกใช้ตัวสร้างที่มีฟังก์ชันเรียกกลับให้เรียกใช้ทุกครั้งที่มีการอัปเดตแรงดัน
const observer = new PressureObserver(
(records) => { /* ... */ },
{ sampleInterval: 2000 }
);
ช่วงเวลาตัวอย่าง sampleInterval เท่ากับ 2,000 มิลลิวินาที หมายความว่าจะมีการอัปเดตมากที่สุดทุก 2 วินาที
หากระบบแสดงช่วงเวลาตัวอย่างที่ขอไม่ได้ ระบบจะให้ตัวอย่างในช่วงเวลาที่เหมาะสมที่สุด ตัวอย่างเช่น หากมีการขอช่วงเวลา 2,000 มิลลิวินาที แต่ระบบจะแสดงตัวอย่างได้สูงสุด 1,000 มิลลิวินาที และระบบจะเลือก 1,000 มิลลิวินาที
การใช้เครื่องมือสังเกตความดัน
การเริ่มมีผู้สังเกตความกดดันมีเพียงวิธีเดียวเท่านั้น สำหรับการเรียกต้นทางแต่ละรายการ
observer.observe(source)
observer.observe("cpu");
ในตัวอย่างนี้ "cpu" เป็นแหล่งที่มาของความดันที่เราสนใจ สำหรับตอนนี้เป็นเพียงแหล่งเดียว
ที่มีให้ใช้งาน ในอนาคตอาจมีแหล่งที่มาอื่นๆ เช่น "gpu", "power" หรือ "thermals"
หากต้องการหยุดสังเกตแหล่งที่มา ให้ใช้เมธอด 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, { sampleInterval: 1000 });
await observer.observe("cpu");
และผู้ใช้ยังบังคับให้อ่าน PressureRecord ได้ด้วยการเรียกใช้เมธอด takeRecords()
เมธอด takeRecords() ของอินเทอร์เฟซ PressureObserver จะแสดงผลอาร์เรย์ของออบเจ็กต์ PressureRecords รายการที่จัดเก็บไว้ในเครื่องสังเกตความดัน และล้างข้อมูลออก
Use Case ที่พบบ่อยที่สุดสำหรับวิธีนี้คือการดึงข้อมูลบันทึกความดันที่รอดำเนินการทั้งหมดทันที แต่ยังไม่ได้ประมวลผลโดยฟังก์ชันเรียกกลับของผู้สังเกตการณ์ ก่อนที่จะยกเลิกการเชื่อมต่อผู้สังเกตการณ์ เพื่อให้บันทึกที่รอดำเนินการอยู่ประมวลผลได้เมื่อปิดใช้งานผู้สังเกตการณ์
การเรียกใช้เมธอดนี้จะล้างรายการเรคคอร์ดที่รอดำเนินการ ดังนั้น การเรียกกลับจะไม่ทำงาน
const observer = new PressureObserver(
(records) => { /* Do something with records. */ },
{ sampleInterval: 1000 }
);
await observer.observe("cpu");
setTimeout(() => {
// Forced records reading.
const records = observer.takeRecords();
observer.disconnect();
// Do something with last records if any.
}, 2000);
บอกให้เราทราบเกี่ยวกับการออกแบบ API
มีอะไรเกี่ยวกับ API ที่ทำงานไม่ได้ตามที่คาดไว้ไหม คุณเห็นเมธอดหรือพร็อพเพอร์ตี้ ที่ขาดหายไปสำหรับการใช้ API ไหม ส่งปัญหาด้านข้อมูลจำเพาะหรือความคิดเห็นของรายการที่มีอยู่ในที่เก็บของ GitHub ที่เกี่ยวข้อง
รายงานปัญหาเกี่ยวกับการใช้งาน
คุณพบข้อบกพร่องในการใช้งาน Chromium หรือไม่ หรือการใช้งานแตกต่างจาก ข้อกำหนดหรือไม่ รายงานข้อบกพร่องที่ new.crbug.com อย่าลืมใส่รายละเอียดให้มากที่สุด วิธีการง่ายๆ ในการทำซ้ำ และป้อน Blink>PerformanceAPIs>ComputePressure ในช่อง คอมโพเนนต์