Share via

Zarządzanie energią i temperaturą

  • Artykuł

Gdy HoloLens 2 działa w ciepłych środowiskach lub z dużymi wymaganiami dotyczącymi wydajności (użycie procesora CPU/procesora GPU, użycie urządzeń peryferyjnych itp.), może to być wystarczająco gorące, że podejmuje działania automatycznie, aby utrzymać się przed przegrzaniem. Te akcje obejmują takie elementy jak:

  • Dostosowywanie wydajności ładowania
  • Przekazywanie opinii użytkowników
  • Zamykanie aplikacji

... i w najgorszych scenariuszach:

  • Zamykanie HoloLens 2

Jeśli aplikacja wymaga wysokiej wydajności urządzeń peryferyjnych, rozważ użycie zestawu PowerThermalNotification Software Development Kit (SDK) w celu zasubskrybowania zdarzeń powiadomień i zaimplementowania własnych akcji niestandardowych. Dzięki temu urządzenie może działać dłużej w sytuacjach, gdy w przeciwnym razie aplikacja może zostać zakończona przez system.

Uwaga

Obsługa zestawu MICROSOFT.MixedReality.PowerThermalNotification SDK jest uwzględniona w wersji 22H1.

W tym artykule opisano zestaw POWERThermalNotification SDK i jego podstawowe użycie, aby rozpocząć pracę.

Gdzie mogę uzyskać zestaw SDK?

Zestaw POWERThermalNotification SDK można pobrać za pośrednictwem narzędzia Mixed Reality Feature Tool.

Zestaw POWERThermalNotification SDK obsługuje projekcje językowe dla języków C# i C++, umożliwiając deweloperom tworzenie aplikacji dla platform Win32 lub UWP.

Omówienie pojęć

Moc zużywana przez HoloLens 2 jest rozpraszana w ogniu. Tradycyjne urządzenie pc będzie mieć wentylator, aby rozwiązać ten problem, ale urządzenie do noszenia musi być lekkie. W związku z tym rozwiązanie chłodzące jest bardziej złożone. HoloLens 2 ma wbudowane funkcje bezpieczeństwa sprzętu i oprogramowania, aby upewnić się, że zestaw słuchawkowy nie jest zbyt gorący dla użytkownika, ale te funkcje muszą być również zrównoważone z obsługą użytkownika. Jeśli na przykład wiemy, która część HoloLens 2 się nagrzewa, możemy wybrać ograniczenie urządzeń peryferyjnych odpowiedzialnych za to ciepło. W ostateczności możemy zamknąć aplikację, która jest uważana za odpowiedzialną za moc, która doprowadziła do tego ciepła.

HoloLens 2 obsługuje problemy z temperaturą przy użyciu czujników temperatury. Struktura cieplna łączy grupy czujników z różnymi urządzeniami peryferyjnymi. Czujniki są zgrupowane, ponieważ może być niemożliwe ustalenie, które urządzenie peryferyjne w obszarze fizycznym jest odpowiedzialne za zużycie energii, które ogrzewa HoloLens 2.

Zestaw POWERThermalNotification SDK uwidacznia interfejsy API niezbędne do monitorowania tych grup czujników. Zdarzenia zestawu SDK są uruchamiane, gdy urządzenie peryferyjne używane przez aplikację pokazuje oznaki, że może być wymagane ograniczenie ryzyka. Aplikacja może następnie dostosować swoje środowisko klienta, aby zmniejszyć wpływ cieplny. Zmniejszenie wpływu oznacza mniejsze ryzyko działania systemu, takiego jak zamknięcie aplikacji lub urządzenia.

Prostym przykładem może być aplikacja, która używa procesora CPU do przetwarzania dużej ilości danych wideo. Aplikacja może subskrybować powiadomienie o wydajności składnika procesora CPU. Gdy aplikacja otrzyma powiadomienie, może zmniejszyć obciążenie procesora CPU. Jeśli zostanie odebrane inne zdarzenie, które wskazuje, że żadne dalsze środki zaradcze nie są konieczne, można przywrócić obciążenie procesora CPU.

Odpowiedź na platformę

Poniższa tabela zawiera podział akcji systemowych według urządzeń peryferyjnych. Akcje opisane poniżej można pominąć przy użyciu zestawu SDK. Zobacz Pomijanie domyślnych środków zaradcze systemu

Obwodowych MinimumUserImpact ŚredniuserImpact Maksymalna wartośćUserImpact Ostatnia resort Zamykanie oprogramowania Failsafe
Procesory GPU Ograniczanie jakości
MRC Dostosowywanie interwału VSYNC
Wyświetl Redukcja głębokości na sekundę
Dowolne urządzenie peryferyjne Wyświetlanie ostrzeżenia
Zamknij przechwytywanie mrC zatrzymania aplikacji
Zamykanie systemu operacyjnego Zamykanie sprzętu

Uwaga

Akcje w kolumnach "Last Resort", "Software Shutdown" i "Failsafe" nie mogą być pomijane.

Sugestie dotyczące odpowiedzi aplikacji

Poniżej przedstawiono podział sugerowanych środków zaradczych, które aplikacja może podjąć w oparciu o to, które urządzenia peryferyjne wymagają ograniczenia ryzyka. Do dewelopera aplikacji należy określenie, które z tych akcji może mieć bardziej znaczący wpływ na każde urządzenie peryferyjne, ponieważ każda aplikacja jest inna. Deweloperzy powinni określić priorytety akcji, które podejmują na podstawie wpływu na użytkownika końcowego.

Sugerowane środki zaradcze według urządzeń peryferyjnych

Procesor CPU

Procesory GPU

DRAM

Sieć

Akumulator

Wyświetl

  • Zwiększanie liczby czarnych pikseli w scenie
  • Użyj kolorów o niskiej mocy (na przykład zielonych)
  • Przyciemnianie ekranu

Zdjęcie/aparat wideo

  • Omówienie
  • Zmniejsz rozdzielczość aparatu
  • Zmniejsz szybkość ramki aparatu
  • Zmniejszanie przetwarzania po przetwarzaniu obrazów aparatu przez aplikację
  • Przestań używać aparatu fotograficznego/wideo

Przypadki użycia implementacji

Zestaw SDK jest przeznaczony do obsługi dwóch standardowych przypadków użycia w celu uzyskania informacji:

  • Oparte na zdarzeniach
  • Oparte na sondowaniu

Powiadomienie oparte na zdarzeniach zapewni najszybszą ścieżkę opinii do aplikacji na wypadek potrzeby podjęcia działań. Jednak w niektórych przypadkach deweloper może łatwiej korzystać z sondowania.

Uwaga

Informacje o stanie są aktualizowane co najwyżej kilka sekund dla każdego urządzenia peryferyjnego, więc sondowanie szybciej niż może to spowodować marnowanie cykli procesora CPU.

Użycie interfejsu API opartego na zdarzeniach

Rejestrowanie pod kątem zdarzeń

Aby otrzymywać powiadomienia, istnieją trzy wymagania:

Nie będziesz otrzymywać zdarzeń, jeśli aplikacja nie spełnia tych wymagań.

Pierwszy element można sprawdzić za pomocą funkcji IsSupported . Jeśli system obsługuje powiadomienia dla co najmniej jednego z urządzeń peryferyjnych w masce, funkcja zwróci wartość true. Możesz zrezygnować z sprawdzania obsługi przy użyciu tej funkcji, o ile aplikacja nie zależy jawnie od zdarzeń zestawu POWERThermalNotification SDK.

Po spełnieniu powyższych trzech wymagań otrzymasz początkowe powiadomienia dotyczące wszystkich obsługiwanych urządzeń peryferyjnychOfInterest. Jeśli później zmienisz element PeripheralsOfInterest lub którykolwiek z programów obsługi zdarzeń, otrzymasz kolejny zestaw powiadomień na podstawie bieżącego stanu.

Oto fragment kodu umożliwiający pobranie wystąpienia klasy PowerThermalNotification i skonfigurowanie go na potrzeby powiadomień dla zarówno powerthermalPeripheralFlags.Cpu , jak i PowerThermalPeripheralFlags.PhotoVideoCamera:

using Microsoft.MixedReality.PowerThermalNotification;

private void NotificationHandler(object sender, PowerThermalEventArgs args)
{
    //  Notification handling can be done here using information contained in args
}

private void InitializeThermalNotifications()
{
    PowerThermalNotification p = PowerThermalNotification.GetForCurrentProcess();
    
    PowerThermalPeripheralFlags requestedFlags = PowerThermalPeripheralFlags.Cpu | PowerThermalPeripheralFlags.PhotoVideoCamera;
     if (PowerThermalNotification.IsSupported(requestedFlags))
    {
        //At least one of these peripherals is supported by the system
        p.PeripheralsOfInterest = requestedFlags;
        p.PowerThermalMitigationLevelChanged += NotificationHandler;
    }  
}

Obsługa zdarzeń

Gdy jest uruchamiane zdarzenie PowerThermalMitigationLevelChanged , jest ono dostarczane z elementem PowerThermalEventArgs. Powinny one służyć do zrozumienia zdarzenia.

Podobnie, gdy zdarzenie PowerThermalThermalScoreChanged jest uruchamiane , pochodzi z powerThermalScoreArgs.

Po odebraniu zdarzenia program obsługi zdarzeń powinien sprawdzić args. ImpactedPeripherals, który określa, które urządzenia peryferyjne są dotknięte (może być więcej niż jeden).

W przypadku zdarzeń PowerThermalMitigationLevelChangedargs. MitigationLevel wskazuje, jak poważne ograniczenie ryzyka jest zalecane dla określonych urządzeń peryferyjnych. Jeśli args. MitigationLevel to PowerThermalMitigationLevel.NoUserImpact , a następnie należy usunąć wszelkie środki zaradcze skojarzone z określonymi urządzeniami peryferyjnymi.

W przypadku zdarzeń PowerThermalThermalScoreChangedargs. ThermalScore wskazuje wynik od 100 do 0 odzwierciedlający skalę liniową zbliżającą się do zdarzenia zamknięcia aplikacji (zero). Zakres oceny cieplnej rozpoczyna się poza zakresem raportowania ograniczania ryzyka, aby umożliwić wcześniejsze powiadomienie aplikacji podczas zbliżania się do potrzeby ograniczania ryzyka.

Oto przykładowa procedura obsługi:

bool doCpuThrottle = false;

private void NotificationHandler(object sender, PowerThermalEventArgs args)
{
    if (args.ImpactedPeripherals.HasFlag(PowerThermalPeripheralFlags.Cpu))
    {
        if(args.MitigationLevel = PowerThermalMitigationLevel.NoUserImpact)
        {
            doCpuThrottle = false;
        }
        else if(args.MitigationLevel >= PowerThermalMitigationLevel.MinimumUserImpact)
        {
            // Note that this only kicks in at MinimumUserImpact and does not get released until NoUserImpact
            doCpuThrottle = true;
        }
    }

    if (args.ImpactedPeripherals.HasFlag(PowerThermalPeripheralFlags.PhotoVideoCamera))
    {
        SetMitigationStatus(PhotoVideoCameraStatusText, PhotoVideoRectangle, args.MitigationLevel);
    }
}

Uwaga

Parametr ImpactedPeripherals args identyfikuje tylko te urządzenia peryferyjne, których dotyczyło zarówno wpływ, jak i część PeripheralsOfInterest. Inne urządzenia peryferyjne, których nie dotyczy problem, nie zostały uwzględnione w urządzeniach peryferyjnychOfInterest, nie zostaną zidentyfikowane.

Uwaga

Poziomy ograniczania ryzyka dla urządzeń peryferyjnych mają histerezę. Gdy poziom zostanie zwiększony, nie zostanie zmniejszony, dopóki nie zostanie on wypuszczany. Wydanie jest zdarzeniem z elementami args. MitigationLevel ustaw wartość PowerThermalMitigationLevel.NoUserImpact.

Łączenie go (model oparty na zdarzeniach)

Oto prosty przykład zestawu skryptów, których można użyć w a unity w celu włączenia tej funkcji. Klasę NotificationComponent można dodać do dowolnego obiektu gry, a obiekt gry może śledzić poziom ograniczania ryzyka przypisanego urządzenia peryferyjnego. Klasa NotificationManager zajmuje się zestawem SDK zarządzającym subskrypcjami za pomocą pojedynczego wystąpienia klasy PowerThermalNotification .

Oto klasa NotificationManager:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

using Microsoft.MixedReality.PowerThermalNotification;

public class NotificationManager
{
    private static readonly object listLock = new object();
    private static List<NotificationComponent> components = new List<NotificationComponent>();
    private static PowerThermalNotification p = PowerThermalNotification.GetForCurrentProcess();
    private static bool FirstTime = true;

    private static void NotificationHandler(object sender, PowerThermalEventArgs args)
    {
        lock (listLock)
        {
            foreach (NotificationComponent c in components)
            {
                UnityEngine.WSA.Application.InvokeOnAppThread(() =>
                {
                    c.SetMitigationLevel(args.ImpactedPeripherals, args.MitigationLevel);
                }, false);
            }
        } 
    }

    public static void ChangeSuppression(PowerThermalPeripheralFlags peripherals, bool suppress)
    {
        p.SuppressPlatformMitigation(peripherals, suppress);
    }

    public static void AddNotification(NotificationComponent component, PowerThermalPeripheralFlags peripheralsOfInterest)
    {
        if (FirstTime)
        {
            p.PowerThermalMitigationLevelChanged += NotificationHandler;
            FirstTime = false;
        }
        
        if (PowerThermalNotification.IsSupported(peripheralsOfInterest))
        {
            lock (listLock)
            {
                component.SetMitigationLevel(peripheralsOfInterest, (PowerThermalMitigationLevel)0);
                components.Add(component);
            }
            p.PeripheralsOfInterest |= peripheralsOfInterest;
        }
    }
}

Oto klasa NotificationComponent:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

using Microsoft.MixedReality.PowerThermalNotification;

public class NotificationComponent : MonoBehaviour
{
    //Note that this could be multiple peripherals, just need to make sure to look at impactedPeripherals in the handler
    public PowerThermalPeripheralFlags monitoredPeripheral = (PowerThermalPeripheralFlags) 0;
    public bool isSuppressed = false;

    public void SetMitigationLevel(PowerThermalMitigationLevel level)
    {
        Color newColor = Color.white;

        if (level == PowerThermalMitigationLevel.NoUserImpact)
        {
            newColor = Color.green;
        }
        else if (level == PowerThermalMitigationLevel.MinimumUserImpact)
        {
            newColor = Color.yellow;
        }
        else if (level == PowerThermalMitigationLevel.MediumUserImpact)
        {
            newColor = new Color32(255, 127, 37, 255);//Orange
        }
        else
        {
            newColor = Color.red;
        }

        MaterialPropertyBlock props = new MaterialPropertyBlock();
        props.SetColor("_Color", newColor);
        GetComponent<Renderer>().SetPropertyBlock(props);
    }

    public void SetMitigationLevel(PowerThermalPeripheralFlags impactedPeripherals, PowerThermalMitigationLevel level)
    {
        if (impactedPeripherals.HasFlag(monitoredPeripheral))
        {
            SetMitigationLevel(level);
        }
    }

    void Start()
    {
        NotificationManager.AddNotification(this, monitoredPeripheral);
        NotificationManager.ChangeSuppression(monitoredPeripheral, isSuppressed);
    }

}

Użycie interfejsu API opartego na sondowaniu

Aktualizowanie interesujących urządzeń peryferyjnych

Podobnie jak w przypadku użycia opartego na zdarzeniach, ustawienie właściwości PeripheralsOfInterest jest wymagane do sondowania danego urządzenia peryferyjnego.

Ostrzeżenie

Jeśli spróbujesz wywołać metodę GetLastPeripheralState dla danego urządzenia peryferyjnego bez uprzedniego ustawienia tej flagi w elementu PeripheralsOfInterest, zostanie zgłoszony wyjątek. Podobnie, jeśli spróbujesz użyć metody GetLastPeripheralState z nieprawidłową wartością (zestaw bitów z wieloma flagami lub nieobsługiwanym bitem), zostanie zgłoszony wyjątek.

Wywoływanie interfejsów API sondowania

Gdy urządzenia peryferyjneOfInterest ma zestaw bitów peryferyjnych, które chcesz sondować, możesz wywołać metodę GetLastPeripheralState.

Zwrócony parametr PowerThermalPeripheralState zawiera najnowsze wartości dla parametru Thermal Score i Mitigation Level dla danego urządzenia peryferyjnego.

Uwaga

Istnieje możliwość, że w przyszłych platformach niektóre urządzenia peryferyjne mogą nie być obsługiwane. W takich przypadkach interfejs API zwróci wynik termiczny 100 i poziom ograniczania ryzyka noUserImpact. Aplikacja może sprawdzić pole IsSupportedPeripheral struktury, aby sprawdzić, czy tak jest w przypadku danego urządzenia peryferyjnego.

Zobacz Handling Events (Obsługa zdarzeń ), aby uzyskać szczegółowe informacje na temat obsługi współczynnika cieplnego i ograniczenia ryzyka zwróconego przez parametr PowerThermalPeripheralState.

Oto mały fragment kodu przedstawiający sondowanie:

private async void timerCallback(object state)
{
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    {
        PowerThermalNotification p = PowerThermalNotification.GetForCurrentProcess();

        PowerThermalPeripheralState CpuState = p.GetLatestPeripheralState(PowerThermalPeripheralFlags.Cpu);
        PowerThermalPeripheralState PhotoVideoCameraState = p.GetLatestPeripheralState(PowerThermalPeripheralFlags.PhotoVideoCamera);
        
        CpuScoreText.Text = CpuState.ThermalScore.ToString();
        PhotoVideoScoreText.Text = PhotoVideoCameraState.ThermalScore.ToString();
    });
}

private void InitializeThermalNotifications()
{
    PowerThermalNotification p = PowerThermalNotification.GetForCurrentProcess();

    PowerThermalPeripheralFlags requestedFlags = PowerThermalPeripheralFlags.Cpu | PowerThermalPeripheralFlags.PhotoVideoCamera;
    p.SuppressedPlatformMitigationForPeripherals = requestedFlags;//Suppress any platform mitigation on CPU or PhotoVideoCamera

    if (PowerThermalNotification.IsSupported(requestedFlags))
    {
        p.PeripheralsOfInterest = requestedFlags;

        Timer timer = new Timer(timerCallback, null, 0, 3000);
    }
    else
    {
        TitleLabel.Text = "Not Supported";
    }
}

Pomijanie domyślnych środków zaradczych dotyczących systemu

Jeśli nie chcesz, aby system próbował złagodzić niektóre urządzenia peryferyjne, możesz je pominąć. Aby to zrobić, wystarczy zaktualizować właściwość SuppressedPlatformMitigationForPeripherals lub wywołać funkcję SuppressPlatformMitigation .

Oto mały fragment kodu:

PowerThermalNotification p = PowerThermalNotification.GetForCurrentProcess();
PowerThermalPeripheralFlags requestedFlags = PowerThermalPeripheralFlags.Cpu | PowerThermalPeripheralFlags.PhotoVideoCamera;

//You can do this to set the property explicitly
p.SuppressedPlatformMitigationForPeripherals = requestedFlags;

//Or you can do this to manipulate the property mask. 
//This specific example clears the CPU, leaving the PhotoVideoCamera suppressed
p.SuppressPlatformMitigation(PowerThermalPeripheralFlags.Cpu, false);

Uwaga

Interfejsy API pomijania będą działać tylko wtedy, gdy proces korzystający z klasy PowerThermalNotification znajduje się na pierwszym planie. Procesy w tle mogą nadal subskrybować zdarzenia, ale mogą nie wyłączać HoloLens 2 akcji.

Testowanie

Po zintegrowaniu zestawu SDK z aplikacją należy go przetestować. W przypadku HoloLens 2 systemów operacyjnych, które obsługują zestaw SDK, strona dewelopera będzie dostępna w portalu urządzeń. Na tej stronie można kontrolować poziomy ograniczania ryzyka i wyniki cieplne dla każdego urządzenia peryferyjnego. Można również monitorować, które urządzenia peryferyjne mają aktywnie pomijane środki zaradcze.

Interfejsy API REST można również wykorzystać do monitorowania/testowania poziomów ograniczania ryzyka i wyników cieplnych z innego urządzenia. Więcej informacji można znaleźć w dokumentacji interfejsu API portalu urządzeń