CodeCache in JVM Builds

  
======================
   General JIT info   
======================

            JIT is :      on
  Compiler threads :      12

CodeCache overview
--------------------------------------------------------

         Reserved size :  245760 KB
        Committed size :    8064 KB
  Unallocated capacity :  240064 KB


__ CodeHeapStateAnalytics lock wait took      0.000 seconds _________


__ Compile & CodeCache (global) lock wait took      0.000 seconds _________

=============================================================
=  C O D E   H E A P   A N A L Y S I S   (general remarks)  =
=============================================================
   The code heap analysis function provides deep insights into
   the inner workings and the internal state of the Java VM's
   code cache - the place where all the JVM generated machine
   code is stored.
   
   This function is designed and provided for support engineers
   to help them understand and solve issues in customer systems.
   It is not intended for use and interpretation by other persons.
   

======================================================================================================
=  C O D E   H E A P   A N A L Y S I S   (used blocks) for segment CodeHeap 'non-profiled nmethods'  =
======================================================================================================
   The aggregate step takes an aggregated snapshot of the CodeHeap.
   Subsequent print functions create their output based on this snapshot.
   The CodeHeap is a living thing, and every effort has been made for the
   collected data to be consistent. Only the method names and signatures
   are retrieved at print time. That may lead to rare cases where the
   name of a method is no longer available, e.g. because it was unloaded.

   CodeHeap committed size 2496K (2M), reserved size 119168K (116M), 2% occupied.
   CodeHeap allocation segment size is 128 bytes. This is the smallest possible granularity.
   CodeHeap (committed part) is mapped to 624 granules of size 4096 bytes.
   Each granule takes 40 bytes of C heap, that is 24K in total for statistics data.
   The number of granules is limited to 512k, requiring a granules size of at least 2048 bytes for a 1GB heap.

+---------------------------------------------------------------------------+
|  Global CodeHeap statistics for segment CodeHeap 'non-profiled nmethods'  |
+---------------------------------------------------------------------------+
freeSpace        =        0k, nBlocks_free     =      0,      0.000% of capacity,      0.000% of max_capacity
usedSpace        =      367k, nBlocks_used     =    349,     14.704% of capacity,      0.308% of max_capacity
  Tier1 Space    =      183k, nBlocks_t1       =    234,      7.342% of capacity,      0.154% of max_capacity
  Tier2 Space    =      149k, nBlocks_t2       =    104,      5.985% of capacity,      0.125% of max_capacity
  Alive Space    =       34k, nBlocks_alive    =     11,      1.377% of capacity,      0.029% of max_capacity
    disconnected =        0k, nBlocks_disconn  =      0,      0.000% of capacity,      0.000% of max_capacity
    not entrant  =       34k, nBlocks_notentr  =     11,      1.377% of capacity,      0.029% of max_capacity
  stubSpace      =       34k, nBlocks_stub     =     11,      1.377% of capacity,      0.029% of max_capacity
ZombieBlocks     =        0. These are HeapBlocks which could not be identified as CodeBlobs.

Segment start          = 0x0000000114eb8000, used space      =     2496k
Segment end (used)     = 0x0000000115128000, remaining space =   116672k
Segment end (reserved) = 0x000000011c318000, reserved space  =   119168k

latest allocated compilation id = 1232
highest observed compilation id = 1230
Building TopSizeList iterations = 11042

Verifying collected data......done


+------------------------------------------------------------+
|  no free blocks found in CodeHeap 'non-profiled nmethods'  |
+------------------------------------------------------------+
==================================================================================================
=  C O D E   H E A P   A N A L Y S I S   (used blocks) for segment CodeHeap 'profiled nmethods'  =
==================================================================================================
   The aggregate step takes an aggregated snapshot of the CodeHeap.
   Subsequent print functions create their output based on this snapshot.
   The CodeHeap is a living thing, and every effort has been made for the
   collected data to be consistent. Only the method names and signatures
   are retrieved at print time. That may lead to rare cases where the
   name of a method is no longer available, e.g. because it was unloaded.

   CodeHeap committed size 2496K (2M), reserved size 119152K (116M), 2% occupied.
   CodeHeap allocation segment size is 128 bytes. This is the smallest possible granularity.
   CodeHeap (committed part) is mapped to 624 granules of size 4096 bytes.
   Each granule takes 40 bytes of C heap, that is 24K in total for statistics data.
   The number of granules is limited to 512k, requiring a granules size of at least 2048 bytes for a 1GB heap.

+-----------------------------------------------------------------------+
|  Global CodeHeap statistics for segment CodeHeap 'profiled nmethods'  |
+-----------------------------------------------------------------------+
freeSpace        =        0k, nBlocks_free     =      0,      0.000% of capacity,      0.000% of max_capacity
usedSpace        =     2353k, nBlocks_used     =    883,     94.291% of capacity,      1.975% of max_capacity
  Tier1 Space    =     2053k, nBlocks_t1       =    768,     82.257% of capacity,      1.723% of max_capacity
  Tier2 Space    =        0k, nBlocks_t2       =      0,      0.000% of capacity,      0.000% of max_capacity
  Alive Space    =      300k, nBlocks_alive    =    115,     12.034% of capacity,      0.252% of max_capacity
    disconnected =        0k, nBlocks_disconn  =      0,      0.000% of capacity,      0.000% of max_capacity
    not entrant  =      300k, nBlocks_notentr  =    115,     12.034% of capacity,      0.252% of max_capacity
  stubSpace      =      300k, nBlocks_stub     =    115,     12.034% of capacity,      0.252% of max_capacity
ZombieBlocks     =        0. These are HeapBlocks which could not be identified as CodeBlobs.

Segment start          = 0x000000010d318000, used space      =     2496k
Segment end (used)     = 0x000000010d588000, remaining space =   116656k
Segment end (reserved) = 0x0000000114774000, reserved space  =   119152k

latest allocated compilation id = 1232
highest observed compilation id = 1232
Building TopSizeList iterations = 26436

Verifying collected data......done


+--------------------------------------------------------+
|  no free blocks found in CodeHeap 'profiled nmethods'  |
+--------------------------------------------------------+
=============================================================================================
=  C O D E   H E A P   A N A L Y S I S   (used blocks) for segment CodeHeap 'non-nmethods'  =
=============================================================================================
   The aggregate step takes an aggregated snapshot of the CodeHeap.
   Subsequent print functions create their output based on this snapshot.
   The CodeHeap is a living thing, and every effort has been made for the
   collected data to be consistent. Only the method names and signatures
   are retrieved at print time. That may lead to rare cases where the
   name of a method is no longer available, e.g. because it was unloaded.

   CodeHeap committed size 3072K (3M), reserved size 7440K (7M), 41% occupied.
   CodeHeap allocation segment size is 128 bytes. This is the smallest possible granularity.
   CodeHeap (committed part) is mapped to 768 granules of size 4096 bytes.
   Each granule takes 40 bytes of C heap, that is 30K in total for statistics data.
   The number of granules is limited to 512k, requiring a granules size of at least 2048 bytes for a 1GB heap.

+------------------------------------------------------------------+
|  Global CodeHeap statistics for segment CodeHeap 'non-nmethods'  |
+------------------------------------------------------------------+
freeSpace        =       46k, nBlocks_free     =      6,      1.501% of capacity,      0.620% of max_capacity
usedSpace        =     2974k, nBlocks_used     =    442,     96.834% of capacity,     39.983% of max_capacity
  Tier1 Space    =        0k, nBlocks_t1       =      0,      0.000% of capacity,      0.000% of max_capacity
  Tier2 Space    =        0k, nBlocks_t2       =      0,      0.000% of capacity,      0.000% of max_capacity
  Alive Space    =        0k, nBlocks_alive    =      0,      0.000% of capacity,      0.000% of max_capacity
    disconnected =        0k, nBlocks_disconn  =      0,      0.000% of capacity,      0.000% of max_capacity
    not entrant  =        0k, nBlocks_notentr  =      0,      0.000% of capacity,      0.000% of max_capacity
  stubSpace      =     2974k, nBlocks_stub     =    442,     96.834% of capacity,     39.983% of max_capacity
ZombieBlocks     =        0. These are HeapBlocks which could not be identified as CodeBlobs.

Segment start          = 0x0000000114774000, used space      =     3072k
Segment end (used)     = 0x0000000114a74000, remaining space =     4368k
Segment end (reserved) = 0x0000000114eb8000, reserved space  =     7440k

latest allocated compilation id = 1232
highest observed compilation id = 0
Building TopSizeList iterations = 6908

Verifying collected data......done
  
  

  
#!/bin/bash

# Find the latest Java process ID
PID=$(pgrep -f '.*java.*' | xargs -I{} ps -o pid= -o lstart= -p {} | sort -k2,3 | tail -n 1 | awk '{print $1}')

if [ -z "$PID" ]; then
    echo "No process found."
    exit 1
fi

# Run jcmd to get the Compiler.CodeHeap_Analytics output
OUTPUT=$(jcmd $PID Compiler.CodeHeap_Analytics)
echo "Monitoring JVM CodeCache (PID: $PID)"

# Function to convert size with units (KB, MB) into bytes
convert_to_bytes() {
    local value=$1
    local unit=$2

    case $unit in
        KB)
            echo $(printf "%.0f" $(echo "$value * 1024" | bc))
            ;;
        k)
            echo $(printf "%.0f" $(echo "$value * 1024" | bc))
            ;;
        K)
            echo $(printf "%.0f" $(echo "$value * 1024" | bc))
            ;;
        MB)
            echo $(printf "%.0f" $(echo "$value * 1024 * 1024" | bc))
            ;;
        m)
            echo $(printf "%.0f" $(echo "$value * 1024 * 1024" | bc))
            ;;
        M)
            echo $(printf "%.0f" $(echo "$value * 1024 * 1024" | bc))
            ;;
        *)
            
            echo $(printf "%.0f" $value)  # Already in bytes, ensure it's an integer
            ;;
    esac
}

# Function to extract the used and committed space for a segment
extract_code_cache_segment_data() {
  local segment_name=$1
  local used_space=$(echo "$OUTPUT" | sed -n "/Global CodeHeap statistics for segment CodeHeap '$segment_name'/,/Verifying collected data/p" | grep 'usedSpace' | awk '{print $3}' | head -1)
  local used_space_value=$(echo "$used_space" | grep -o -E '[0-9]+')
  local used_space_unit=$(echo "$used_space" | grep -o -E '[^0-9, ]+')
  local commited_size=$(echo "$OUTPUT" | sed -n "/C O D E   H E A P   A N A L Y S I S   (used blocks) for segment CodeHeap '$segment_name'/,/Verifying collected data/p" | grep "CodeHeap committed size" | awk '{print $4}' | head -1)
  local commited_size_value=$(echo "$commited_size" | grep -o -E '[0-9]+')
  local commited_size_unit=$(echo "$commited_size" | grep -o -E '[^0-9, ]+')
  echo "$(convert_to_bytes $used_space_value $used_space_unit)" "$(convert_to_bytes $commited_size_value $commited_size_unit)"
}

# Extract data for each segment
non_profiled_data=$(extract_code_cache_segment_data 'non-profiled nmethods')
profiled_data=$(extract_code_cache_segment_data 'profiled nmethods')
non_nmethods_data=$(extract_code_cache_segment_data 'non-nmethods')

# Split the data into used and committed for each segment
non_profiled_used=$(echo $non_profiled_data | awk '{print $1}')
non_profiled_committed=$(echo $non_profiled_data | awk '{print $2}')
non_profiled_used_value=$(echo "$non_profiled_used" | grep -o -E '[0-9]+')
non_profiled_committed_value=$(echo "$non_profiled_committed" | grep -o -E '[0-9]+')

profiled_used=$(echo $profiled_data | awk '{print $1}')
profiled_committed=$(echo $profiled_data | awk '{print $2}')
profiled_used_value=$(echo "$profiled_used" | grep -o -E '[0-9]+')
profiled_committed_value=$(echo "$profiled_committed" | grep -o -E '[0-9]+')

non_nmethods_used=$(echo $non_nmethods_data | awk '{print $1}')
non_nmethods_committed=$(echo $non_nmethods_data | awk '{print $2}')
non_nmethods_used_value=$(echo "$non_nmethods_used" | grep -o -E '[0-9]+')
non_nmethods_committed_value=$(echo "$non_nmethods_committed" | grep -o -E '[0-9]+')

# Total up the used and committed space
total_used_value=$((non_profiled_used_value + profiled_used_value + non_nmethods_used_value))
total_committed_value=$((non_profiled_committed_value + profiled_committed_value + non_nmethods_committed_value))

# Print the results
echo "=== CodeCache Breakdown ==="
echo "Non-profiled nmethods:"
echo "  Used: $((non_profiled_used / 1024)) KB"
echo "  Committed: $((non_profiled_committed / 1024)) KB"
echo ""
echo "Profiled nmethods:"
echo "  Used: $((profiled_used / 1024)) KB"
echo "  Committed: $((profiled_committed / 1024)) KB"
echo ""
echo "Non-nmethods:"
echo "  Used: $((non_nmethods_used / 1024)) KB"
echo "  Committed: $((non_nmethods_committed / 1024)) KB"
echo ""
echo "=== Total ==="
echo "Total Used: $((total_used_value / 1024)) KB"
echo "Total Committed: $((total_committed_value / 1024)) KB"
echo ""