Dela via

Minnesanvändning i program på hög nivå

  • Artikel

Det här avsnittet innehåller information om minnesanvändning i program på hög nivå. Se Hantera minnes- och svarstidsöverväganden för information om det minne som är tillgängligt för rtapps (real-time capable applications).

Program på hög nivå har åtkomst till följande minne och lagring:

  • 256 KiB RAM på hög nivå kärna, reserverad helt för hög nivå programanvändning. Upp till 1 KiB av detta utrymme kan tilldelas för varje delad buffertkanal genom vilken program på hög nivå och RTApps kommunicerar.
  • 1 MiB skrivskyddad flashminne, som delas mellan kärnorna på hög nivå och realtid.
  • Läs-/skrivlagring (avstängt) som finns kvar när en enhet startas om. Mer information om anpassningsbar lagring finns i Använda lagring på Azure Sphere.

Observera

Om du uppdaterar blixten upprepade gånger slits den ut så småningom och gör den ogiltig. Därför bör du utforma koden för att undvika onödiga uppdateringar av blixten. Om du till exempel vill spara programtillståndet innan du avslutar det så att du kan återställa det sparade tillståndet efter en omstart kan du spara programmets tillstånd på blixten endast om tillståndet har ändrats.

Fastställ minnesanvändning för flashminne

Ta bara hänsyn till storleken på avbildningspaketfilen som innehåller avbildningsmetadata, programmanifestet och den körbara avbildningen för att avgöra hur mycket flashminne du använder. Du behöver inte redovisa den lagring som krävs av Microsoft-tillhandahållna komponenter, till exempel Azure Sphere OS eller de körningstjänster och delade bibliotek som styr kringutrustning och aktiverar anslutning till en Azure IoT Hub. På samma sätt behöver du inte ta med storleken på en fullständig säkerhetskopia av programmet eller komponenterna som möjliggör redundans eller återställning om det uppstår skador eller problem med uppdateringar som inte ingår.

Under utveckling och felsökning räknas dock storleken på felsökaren mot gränsen. Felsökaren läggs automatiskt till av azsfärenhetens enable-development och tas bort av azsfärenheten enable-cloud-test. Du hittar storleken på felsökaren som används av SDK:et genom att söka efter gdbserver.imagepackage i mappen DebugTools i installationskatalogen för Microsoft Azure Sphere SDK.

Kommandot azsfärenhet för separat inläsning returnerar ett fel om programbildpaketet och felsökaren (om det finns) överskrider den totala gränsen på 1 MiB. Azsfärbildstillägget --avbildningskommandot som laddar upp en ny avbildning till Azure Sphere-klientorganisationen returnerar också ett fel om avbildningspaketet överskrider 1 MiB.

Gränsen på 256 KiB RAM gäller enbart för ansökan. behöver du inte tillåta RAM-minne som används av felsökaren. Ytterligare minne är reserverat för kernelallokering.

Den tillgängliga blixten och RAM-minnet kan öka (men kommer aldrig att minska) för program som är skrivna för det aktuella Azure Sphere-chipet (MT3620). Framtida Azure Sphere-kretsar kan ha olika begränsningar.

Slut på minnesförhållanden

Om programmet använder för mycket RAM-minne avslutar Azure Sphere-operativsystemet det med en SIGKILL-signal. I felsökaren ser du till exempel följande:

Child terminated with signal = 0x9 (SIGKILL)

SIGKILL-signalen inträffar också om ett program på hög nivå inte kan avslutas efter att SIGTERM-begäran har mottagits. Mer information finns i Livscykel för ett program .

Information om hur du undviker krascher i programmet på grund av minnesbrist finns i metodtips för hantering av RAM-användning i program på hög nivå.

Fastställ RAM-användning i körningsprogram

Azure Sphere innehåller flera funktioner för att hämta information om minnesanvändning vid körning. Du kan använda dessa för att övervaka högnivåprogrammets minnesanvändning, så att du kan starta om programmet på ett säkert sätt om minnesanvändningen överskrider ett tröskelvärde som du anger inom gränsen på 256 KiB. De tillgängliga funktionerna är:

  • Applications_GetTotalMemoryUsageInKB: Få den totala minnesanvändningen i kibibyte. Det här är den totala fysiska minnesanvändningen för din app i systemet, inklusive kernelallokeringar (t.ex. buffertar för socketar) för din app eller felsökningsservern, som returneras som ett raw-värde (i KiB).
  • Applications_GetUserModeMemoryUsageInKB: Hämta minnesanvändning i användarläge i kibibyte. Det här är mängden fysiskt minne som används direkt av appen, det minne som används av bibliotek för dess räkning (kallas även anonallokering ) och minne som används av felsökningsservern, som returneras som ett raw-värde (i KiB).
  • Applications_GetPeakUserModeMemoryUsageInKB: Få den högsta minnesanvändningen i användarläget i kibibyte. Det här är den maximala mängden användarminne som används i den aktuella sessionen. När du testar minnesanvändningen för ditt program bör du se till att det här värdet aldrig överskrider 256 KiB. Det här värdet återställs när appen startas om eller distribueras om. Använd den här funktionen för att få en ungefärlig inblick i hur nära programmet når den rekommenderade gränsen på 256 KiB.

Om du vill använda de här funktionerna i programmet på hög nivå tar du med rubrikfilen applications.h. Du kan använda de här funktionerna under utvecklingen för att få en uppfattning om programmets totala minnesanvändning, men du kan också använda dem tillsammans med loggning för att samla in information från enheter i fältet. I kodavsnittet Minnesöveranvändning kan du se hur du identifierar och hanterar oväntad minnesanvändning.

Observera

Dessa funktioner returnerar minnesanvändningen enligt operativsystemet. För närvarande rapporteras inte frigörande av minne av ett program för allokering på användarhögen av dessa funktioner. Minnet kommer att returneras till malloc-biblioteket för framtida användning, men statistiken som rapporterats av operativsystemet förblir oförändrad om inte minnet allokerades och frigjorts av själva operativsystemet. Ett exempel är att allokera minne för en socket. Därför är de här funktionerna användbara för att förstå värsta tänkbara scenarier som hjälper ditt program att fungera försiktigt för maximal tillförlitlighet. Värdena är ungefärliga och kan variera mellan os-versioner.

Lägga till minnesallokeringsspårning för heap

Du kan få ytterligare information om minnesanvändning genom att lägga till minnesallokeringsspårning för heapminne, som visar vilka användar- och kerneltilldelningar som görs av statiska och dynamiskt länkade bibliotek. Detta ger en mer fullständig bild av var minnet används av programmet för att hjälpa dig att använda det på effektivast möjliga sätt. Den här funktionen, som är tillgänglig med Azure Sphere OS version 21.07 eller senare och version av programkörning (ARV) 10 eller senare, fungerar bara på en utvecklingsaktiverad enhet och endast när programmet inte körs under felsökningsfunktionen.

Observera

Du måste slutföra båda konfigurationsuppgifterna som beskrivs i det här avsnittet för att funktionen för minnesallokeringsspårning för heapminne ska fungera korrekt. Om du inte gör det rapporteras en varning under sammanställningen och minnesinformation för heap visas inte.

Om du vill aktivera minnesallokeringsspårning för heapminne måste du göra två saker:

  • Lägg till funktionen HeapMemStats i programmets app-manifest.json-fil:

      "Capabilities": {
    "HeapMemStats": true
  },

  • Lägg till libmalloc-biblioteket i avbildningspaketet genom att lägga DEBUG_LIB "libmalloc" till azsphere_target_add_image kommandot i programmets CMakeLists.txt-fil:

    azsphere_target_add_image_package(${PROJECT_NAME} DEBUG_LIB "libmalloc")

Viktigt

Eftersom minnesallokeringsspårning för heap fungerar endast på utvecklingsaktiverade enheter bör du göra följande för att ta bort det från programmet innan du skapar avbildningspaket för distribution:

  • Ta bort raden "HeapMemStats": true" från programmets app-manifest.json-fil.
  • Ta bort DEBUG_LIB "libmalloc" från azsphere_target_add_image_package(${PROJECT_NAME} DEBUG_LIB "libmalloc" kommandot i programmets CMakeLists.txt-fil.

Använda Visual Studio performance profiler

Om du använder Visual Studio kan du använda dess prestandaprofileringsfunktion för att få information om programminnesanvändning. En självstudiekurs som använder den här profileraren finns i Självstudier/Minnesanvända.

Förutsättningar

Starta minnesanvändningsprofilering

  1. Välj Felsök>Prestandaprofilering eller tryck på Alt+F2 för att öppna startfönstret för prestandaprofilering.

    Fönstret Performance Profilering för Visual Studio

  2. Om Azure Sphere Device Profiler inte visas under Analysis Target väljer du Välj mål och sedan Azure Sphere Device Profiler.

  3. Under Tillgängliga verktyg kontrollerar du att Azure Sphere Minnesanvändning är markerat och väljer sedan Start för att öppna fönstret för minnesanvändningsprofilering och starta minnesprofilering.

  4. Om du behöver distribuera eller starta om programmet väljer du Felsöka>Start utan felsökning eller trycker på Ctrl+F5 för att distribuera programmet till enheten.

    Viktigt

    För att få korrekt information om RAM-användning för programmet är det viktigt att du [startar appen utan att felsöka](buid-hl-app.md#build-and-deploy-the-application-in- visual-studio-without-debugging). Om du kör appen under felsökaren får du uppblåst RAM-användning, eftersom minne som används av felsökningsservern inkluderas i den rapporterade RAM-användningsstatistiken.

Tolka minnesanvändningsprofileringsdata

I fönstret för minnesanvändningsprofilering visas en vy som följande:

Fönstret Visual Studio minnesanvändningsprofilering

I mitten av vyn ritar ett Azure Sphere Device Physical Memory-diagram tre olika RAM-användningsstatistik (visas till närmaste KiB) som tre olika rader medan appen körs:

  • Totala: Den totala fysiska minnesanvändningen för appen i systemet, inklusive kernelallokeringar (t.ex. buffertar för socketar) för din app eller felsökningsservern.
  • Användaren: Mängden fysiskt minne som används direkt av appen, det minne som används av bibliotek för dess räkning (kallas även anonallokering ) och minne som används av felsökningsservern.
  • Toppanvändare: Maximalt användarminne som används i den aktuella sessionen. När du testar minnesanvändningen för ditt program bör du se till att det här värdet aldrig överskrider 256 KiB. Ytterligare minne är reserverat för kernelallokering. Det här värdet återställs när appen startas om eller distribueras om.

Diagrammet ritar också förekomster av händelsen New Peak (representeras av en triangel). Den här händelsen inträffar när det finns ett nytt maxvärde för Högsta användarminnesanvändning. Händelsen är aktiverad för hjälpmedel för skärmläsare.

Om du har aktiverat minnesallokeringsspårning för heapminne och programmet inte körs under felsökaren visas ytterligare ett diagram som visar minnesstatistik för heap:

  • Total heap: Det totala heapminnet som tilldelats av eller för ditt program, inklusive från statiska och dynamiska bibliotek.
  • Heap för delat bibliotek: Allokeringar från dynamiskt länkade bibliotek som tillhandahålls av Azure Sphere OS.

Visual Studio heap minnesanvändning

Ovanför graferna visas en tidslinjevy med appens körningstid, korrelerad med data i diagrammet nedan. Använd Zooma in och Zooma ut för att fokusera på specifika tidsperioder.

Under diagrammet visas samma minnesstatistik och händelser i en tabellvy.

Tips

Om du vill kopiera data från tabellen till Urklipp trycker du på Ctrl+A för att markera alla rader och trycker sedan på Ctrl+C.

De två första graferna som visas i det här avsnittet togs när du körde steg 1 i självstudiekursen för minnesanvändning, som innehåller en minnesläcka. Minnesanvändningen klättrar monotont i varje graf, vilket ger visuella bevis för läckan. När läckan är åtgärdad, som i steg 2 i självstudiekursen för minnesanvändning, stiger diagrammet och faller när minnet allokeras och distribueras.

Visual Studio heap minnesanvändning utan minnesläcka

Visa statistik över total minnesanvändning

Azsfärenhetsappen show-memory-stats-kommandot returnerar minnesanvändningsstatistik över total minnesanvändning, användningsläge och toppanvändning av användarläge för program som körs på en ansluten enhet. Enheten måste ha funktionen appUtvecklingsenhet konfigurerad för att köra det här kommandot.

Statistik för RAM-användning som visas när appen körs är:

  • Totalt (kernel+ användarläge): Den totala fysiska minnesanvändningen för appen i systemet, inklusive kernelallokeringar (till exempel buffertar för socketar) för din app eller felsökningsservern.
  • Användarläge: Mängden fysiskt minne som används direkt av appen, det minne som används av bibliotek för dess räkning (kallas även anonallokering ) och minne som används av felsökningsservern.
  • Högsta användarläge: Maximalt användarminne som används i den aktuella sessionen. När du testar minnesanvändningen för ditt program bör du se till att det här värdet aldrig överskrider 256 KiB. Ytterligare minne är reserverat för kernelallokering. Det här värdet återställs när appen startas om eller distribueras om.

Om du har aktiverat minnesallokeringsspårning för heapminne och programmet inte körs under felsökaren visas ytterligare rader med minnesstatistik för heap:

  • Heap: App + Statiska bibliotek: Kernel- och användartilldelningarna från din kod och alla bibliotek som är statiskt kopplade till den.
  • Heap: <dynamiska bibliotekstilldelningar>: Allokeringar från enskilda dynamiskt länkade bibliotek som tillhandahålls av Azure Sphere OS.

Kontinuerlig övervakning av minnesanvändning

Om du vill övervaka minnesanvändningen med tiden kan du använda skript för att köra kommandot show-memory-stats för azsfärenhetsappen i en slinga enligt beskrivningen i följande exempel:

Kommandotolken i Windows

Med Anteckningar eller någon annan textredigerare skapar du en kommandoskriptfil memuse.bat med följande innehåll:

@echo off

:loop
call azsphere device app show-memory-stats
choice /d y /t 1 > nul
goto loop

Kör batchskriptet genom att skriva namnet i kommandotolken (eller den fullständiga sökvägen till filen, om den inte finns i den aktuella katalogen):

C:\Users\username> memuse.bat
 -------------------------- -------------
 Name                       Usage (bytes)
 ========================================
 Total (Kernel + User Mode) 65536
 -------------------------- -------------
 User Mode                  36864
 -------------------------- -------------
 Peak User Mode             36864
 -------------------------- -------------
 -------------------------- -------------
 Name                       Usage (bytes)
 ========================================
 Total (Kernel + User Mode) 65536
 -------------------------- -------------
 User Mode                  36864
 -------------------------- -------------
 Peak User Mode             36864
 -------------------------- -------------

Om du vill avsluta skriptet skriver du Ctrl+C i kommandotolken och svarar sedan Y på uppmaningen "Avsluta batchjobb?".

Windows PowerShell

while ($true) {
    azsphere device app show-memory-stats
    Start-Sleep -Seconds 1
}

Minnesanvändning och felsökaren

När du kör appen under felsökaren innehåller den rapporterade minnesstatistiken även minnesanvändningen för felsökningsprocessen och annan ytterligare minnesanvändning som orsakas av felsökning, till exempel att ange brytpunkter. Därför bör du alltid köra appen utan att felsöka när du försöker samla in korrekt minnesstatistik.

Men det kan vara praktiskt att använda minnesanvändningsprofilering om du kör appen med felsökaren. Att ange brytpunkter och gå igenom kodrader samtidigt som relativa ändringar i minnesförbrukningen observeras kan vara en användbar teknik för att identifiera orsakerna till minnesanvändningstoppar eller minnesläckor.

När du felsöker i Visual Studio öppnas Performance Profiler automatiskt, men funktionen visar inte spårning av heapminnesallokering.