Determinazione del requisito di memoria minimo e dell'utilizzo della CPU

Question

Ho lavorato a un progetto software Java, che verrà distribuito su vari dispositivi hardware (ad esempio, raspberry pi, telefono Android).

Prima di rilasciare questo progetto come prodotto, vorrei guidare gli utenti dichiarando chiaramente i requisiti minimi (in termini di memoria e CPU) o dispositivo hardware che l'utente deve avere per eseguire il nostro prodotto software.

Come posso misurarli? Quali sono gli strumenti disponibili per Java?

Answer 1

Si può prendere l'aiuto di jvisualvm percorso di questo strumento è Program Files \ Java \ jdk1.6.0_38 \ bin \ jvisualvm.exe

È possibile utilizzarlo per determinare l'utilizzo della CPU e il consumo di memoria.

Come si può vedere il tuo utilizzo della CPU e utilizzo della memoria. Spero che questo strumento possa aiutarti.

Answer 2

Alcuni dei miei benchmark gratuiti sono scritti in Java, con varianti eseguite su Raspberry Pi e Android. Per saperne di più sul mio sito per i risultati di entrambi, più punto di riferimento e link codice sorgente di download (gratuito):

http://www.roylongbottom.org.uk/Raspberry%20Pi%20Benchmarks.htm#anchor13 http://www.roylongbottom.org.uk/android%20benchmarks.htm

forse più importante della velocità della CPU e dimensioni della memoria sono le versioni di Android e Java. Nel mio caso, le versioni precedenti di JRE non avrebbero eseguito il codice prodotto da JDK successivo e ho letto delle stesse difficoltà con Android.

Answer 3

È possibile ottenere la memoria totale assegnato alla JVM con:

Runtime.getRuntime().totalMemory();

e la memoria libera (la memoria inutilizzata assegnata a JVM) con:

Runtime.getRuntime().freeMemory();

Così , per ottenere la memoria in uso, è possibile sottrarre la memoria libera dalla memoria totale.

Quindi, si potrebbe fare qualcosa di simile:

long Total_Memory =Runtime.getRuntime().totalMemory(); long Free_Memory=Runtime.getRuntime().freeMemory(); long Memory =Total_Memory-Free_Memory;

Answer 4

E 'piuttosto difficile stimare l'utilizzo della memoria in anticipo, e quindi mi consiglia di fare un po' di monitoraggio (sotto carico reale) per ottenere il numeri di ballpark.

Per quanto riguarda la memoria, il tipico grafico di utilizzo dell'heap è simile a quello elencato in this question e simile a una sega. In circostanze normali il punto più alto della sega è dove si verifica il GC. Potresti ridurre questo limite e invocare GC più frequentemente, con ritardi più lunghi/prestazioni peggiori, quindi spetta a te se questi ritardi sono accettabili. Dall'immagine sulla domanda collegata direi che la dimensione minima dell'heap dovrebbe essere 300M più lo stack che è most often insignificant e non fluttua più di tanto, a meno che non facciate molte zangole, ecc.

Per quanto riguarda la CPU - di nuovo, questo dovrebbe venire prima da quello che è trovare accettabile, in tempo reale e alcuni processi di post-elaborazione sono due casi opposti. Java in realtà non aggiunge alcuna specifica a questo. Oracle, ad esempio, ha un short estimation guide for Weblogic server, ma potrebbe non essere pertinente al tuo caso. C'è anche un similar discussion su un sito SO SOON. La cosa migliore è fare qualche test e determinare il punto in cui le cose diventano inaccettabili.

Answer 5

È possibile utilizzare gli strumenti di profilo come JProfiler, JProbe ecc. Per profilare l'utilizzo della CPU e della memoria dell'applicazione sotto carico.

Quando si ottengono i risultati dell'utilizzo della CPU e della memoria del test di lunga durata, ad esempio un test di pochi giorni, si può essere sicuri con i requisiti minimi e anche massimi della propria applicazione java.

Answer 6

ne dite di codice seguente (vedi anche rispondere here)

package client; 

import java.io.File; 

import java.text.NumberFormat; 

public class SystemInfoUtil 
{ 


    private Runtime runtime = Runtime.getRuntime(); 

    public String findInfo() 
    { 
    StringBuilder sb = new StringBuilder(); 
    sb.append(this.getOsInfo()); 
    sb.append(this.getMemInfo()); 
    sb.append(this.getDiskInfo()); 
    return sb.toString(); 
    } 

    public String getOSname() 
    { 
    return System.getProperty("os.name"); 
    } 

    public String getOSversion() 
    { 
    return System.getProperty("os.version"); 
    } 

    public String getOsArch() 
    { 
    return System.getProperty("os.arch"); 
    } 

    public long getTotalMem() 
    { 
    return Runtime.getRuntime().totalMemory(); 
    } 

    public long getUsedMem() 
    { 
    return Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory(); 
    } 

    public String getMemInfo() 
    { 
    NumberFormat format = NumberFormat.getInstance(); 
    StringBuilder sb = new StringBuilder(); 
    long maxMemory = runtime.maxMemory(); 
    long allocatedMemory = runtime.totalMemory(); 
    long freeMemory = runtime.freeMemory(); 
    sb.append("Free memory: "); 
    sb.append(format.format(freeMemory/1024)); 
    sb.append("<br/>"); 
    sb.append("Allocated memory: "); 
    sb.append(format.format(allocatedMemory/1024)); 
    sb.append("<br/>"); 
    sb.append("Max memory: "); 
    sb.append(format.format(maxMemory/1024)); 
    sb.append("<br/>"); 
    sb.append("Total free memory: "); 
    sb.append(format.format((freeMemory + (maxMemory - allocatedMemory))/1024)); 
    sb.append("<br/>"); 
    return sb.toString(); 

    } 

    public String getOsInfo() 
    { 
    StringBuilder sb = new StringBuilder(); 
    sb.append("OS: "); 
    sb.append(this.getOSname()); 
    sb.append("<br/>"); 
    sb.append("Version: "); 
    sb.append(this.getOSversion()); 
    sb.append("<br/>"); 
    sb.append(": "); 
    sb.append(this.getOsArch()); 
    sb.append("<br/>"); 
    sb.append("Available processors (cores): "); 
    sb.append(runtime.availableProcessors()); 
    sb.append("<br/>"); 
    return sb.toString(); 
    } 

    public String getDiskInfo() 
    { 
    /* Get a list of all filesystem roots on this system */ 
    File[] roots = File.listRoots(); 
    StringBuilder sb = new StringBuilder(); 

    /* For each filesystem root, print some info */ 
    for (File root: roots) 
    { 
     sb.append("File system root: "); 
     sb.append(root.getAbsolutePath()); 
     sb.append("<br/>"); 
     sb.append("Total space (bytes): "); 
     sb.append(root.getTotalSpace()); 
     sb.append("<br/>"); 
     sb.append("Free space (bytes): "); 
     sb.append(root.getFreeSpace()); 
     sb.append("<br/>"); 
     sb.append("Usable space (bytes): "); 
     sb.append(root.getUsableSpace()); 
     sb.append("<br/>"); 
    } 
    return sb.toString(); 
    } 
} 

Answer 7

Ci sono alcune opzioni disponibili per il monitoraggio di & che analizzano l'applicazione Java come elencato di seguito.

1. JConsole
2. jvisualvm
3. NewRelic Plugin
4. Yourkit Profiler

Tuttavia, per test di carico è possibile usare l'applicazione come Jmeter per l'applicazione di test su casi d'uso e può anche fare test di stress per determinare il benchmark della build dell'applicazione.

Da non perdere anche l'analisi dei server frontend e backend per l'analisi end-to-end.