SELECT

/*

[NAME]

- HANA_Memory_Overview_1.00.70+

[DESCRIPTION]

- Memory overview

[SOURCE]

- SAP Note 1969700

[DETAILS AND RESTRICTIONS]

- INSTANCE_SHARED_MEMORY_ALLOCATED_SIZE, INSTANCE_TOTAL_MEMORY_ALLOCATED_SIZE not

available with revisions before 60
- INSTANCE_TOTAL_MEMORY_USED_SIZE not available with revisions before 70
- Specifying a non-existing HOST in "Modification section" on SAP HANA <= 121 can
result in a crash (SAP Note 2391546)

[VALID FOR]

- Revisions: >= 1.00.70

- Statistics server type: all

[SQL COMMAND VERSION]

- 2014/03/06: 1.0 (initial version)

- 2014/05/09: 1.1 ('Disk size' section added)
- 2014/12/02: 1.2 ('peak used' size included)
- 2014/12/05: 1.3 (general global_allocation_limit evaluation included)
- 2015/02/24: 1.4 (liveCache size information included)
- 2015/08/26: 1.5 ('Physical memory (used)' included)

[INVOLVED TABLES]

- various

[INPUT PARAMETERS]

[OUTPUT PARAMETERS]

- NAME: Description
- TOTAL_GB: Total size (GB)
- DETAIL_GB: Size on detail level (GB)
- DETAIL2_GB: Size on 2nd detail level (GB)

[EXAMPLE OUTPUT]

-----------------------------------------------------------------------------------
----------------------------------------------------------------------
|NAME |TOTAL_GB |DETAIL_GB |
DETAIL2_GB |
-----------------------------------------------------------------------------------
----------------------------------------------------------------------
|User-defined global allocation limit|not set | |
|
| | | |
|
|License memory limit | 256| |
|
| | | |
|
|License usage | 143| 124 (2014/03/01-2014/03/31)|
|
| | | 143 (2014/04/01-2014/04/30)|
|
| | | 113 (2014/05/01-2014/05/09)|
|
| | | |
|
|Physical memory | 256| 256 (vhbshk0sdb) |
|
| | | |
|
|HANA instance memory (allocated) | 113| 113 (vhbshk0sdb) |
|
| | | |
|
|HANA instance memory (used) | 85| 85 (vhbshk0sdb) |
|
| | | |
|
|HANA shared memory | 23| 23 (vhbshk0sdb) |
|
| | | |
|
|HANA heap memory (used) | 52| 52 (vhbshk0sdb) |
10 (Pool/NameIdMapping/RoDict) |
| | | |
7 (Pool/RowEngine/CpbTree) |
| | | |
5 (Pool/PersistenceManager/PersistentSpace(0)/DefaultLPA/Page)|
| | | |
3 (Pool/RowEngine/SQLPlan) |
| | | |
3 (Pool/malloc/libhdbcs.so) |
| | | |
2 (Pool/AttributeEngine-IndexVector-Single) |
| | | |
2 (Pool/RowEngine/LockTable) |
| | | |
2 (Pool/RowEngine/QueryExecution) |
| | | |
1 (Pool/Statistics) |
| | | |
1 (Pool/AttributeEngine) |
| | | |
|
|Column store size | 19| 19 (vhbshk0sdb) |
3 (WBCROSSGT) |
| | | |
2 (BALDAT) |
| | | |
1 (DBTABLOG) |
| | | |
1 (DOKTL) |
| | | |
1 (HOST_SQL_PLAN_CACHE) |
| | | |
1 (COMM_PRODUCT_IDX) |
| | | |
1 (REPOSRC) |
| | | |
|
|Row store size | 30| 26 (vhbshk0sdb) |
5 (D010TAB) |
| | | |
3 (D010INC) |
| | | |
2 (REPOSRC) |
| | | |
2 (INDX) |
| | | |
2 (DD03L) |
| | | |
1 (VRSMODISRC) |
| | | |
1 (SMIMCONT1) |
| | | |
1 (SEOCOMPODF) |
| | | |
1 (CWBCIDATAOBJ) |
| | | |
1 (DD04T) |
| | | |
|
|Disk size | 66| 66 (global) |
10 (REPOLOAD) |
| | | |
6 (REPOSRC) |
| | | |
3 (WBCROSSGT) |
| | | |
3 (D010TAB) |
| | | |
3 (DBTABLOG) |
| | | |
2 (INDX) |
| | | |
2 (D010INC) |
| | | |
2 (BALDAT) |
| | | |
2 (DOKTL) |
| | | |
1 (HOST_SQL_PLAN_CACHE) |
-----------------------------------------------------------------------------------
----------------------------------------------------------------------

*/
 'License memory limit' NAME,
LPAD(ROUND(PRODUCT_LIMIT), 9) TOTAL_GB,
' ' DETAIL_GB,
' ' DETAIL2_GB
FROM
M_LICENSE
UNION ALL
( SELECT
' ',
' ',
' ',
' '
FROM
DUMMY
)
UNION ALL
( SELECT
MAP(ROW_NUMBER () OVER (ORDER BY LH.PERIOD_START_TIME), 1, 'License usage', '
'),
MAP(ROW_NUMBER () OVER (ORDER BY LH.PERIOD_START_TIME), 1,
LPAD(ROUND(L.PRODUCT_USAGE), 9), ' '),
LPAD(ROUND(LH.PRODUCT_USAGE), 9) || ' (' || TO_VARCHAR(PERIOD_START_TIME,
'YYYY/MM/DD') ||
'-' || TO_VARCHAR(PERIOD_END_TIME, 'YYYY/MM/DD') || ')',
' '
FROM
M_LICENSE L,
M_LICENSE_USAGE_HISTORY LH
ORDER BY
PERIOD_START_TIME
)
UNION ALL
( SELECT
' ',
' ',
' ',
' '
FROM
DUMMY
)
UNION ALL
( SELECT
MAP(ROW_NUMBER () OVER (ORDER BY HOST), 1, 'Physical memory (available)', ' '),
MAP(ROW_NUMBER () OVER (ORDER BY HOST), 1, LPAD(ROUND(SUM(TO_NUMBER(VALUE))
OVER () / 1024 / 1024 / 1024), 9), ' '),
LPAD(ROUND(TO_NUMBER(VALUE) / 1024 / 1024 / 1024), 9) || ' (' || HOST || ')',
' '
FROM
M_HOST_INFORMATION
WHERE
KEY = 'mem_phys'
ORDER BY
HOST
)
UNION ALL
( SELECT
' ',
' ',
' ',
 ' '
FROM
DUMMY
)
UNION ALL
( SELECT
MAP(ROW_NUMBER () OVER (ORDER BY HOST), 1, 'Physical memory (used)', ' '),
MAP(ROW_NUMBER () OVER (ORDER BY HOST), 1, LPAD(ROUND(SUM(USED_PHYSICAL_MEMORY)
OVER () / 1024 / 1024 / 1024), 9), ' '),
LPAD(ROUND(USED_PHYSICAL_MEMORY / 1024 / 1024 / 1024), 9) || ' (' || HOST ||
')',
' '
FROM
M_HOST_RESOURCE_UTILIZATION
ORDER BY
HOST
)
UNION ALL
( SELECT
' ',
' ',
' ',
' '
FROM
DUMMY
)
UNION ALL
( SELECT
MAP(ROW_NUMBER () OVER (ORDER BY HOST), 1, 'Global allocation limit', ' ')
NAME,
MAP(ROW_NUMBER () OVER (ORDER BY HOST), 1, LPAD(ROUND(SUM(ALLOCATION_LIMIT /
1024 / 1024 / 1024) OVER ()), 9), ' ') TOTAL_GB,
LPAD(ROUND(ALLOCATION_LIMIT / 1024 / 1024 / 1024), 9) || ' (' || HOST || ')'
DETAIL_GB,
' ' DETAIL2_GB
FROM
M_HOST_RESOURCE_UTILIZATION
)
UNION ALL
( SELECT
' ',
' ',
' ',
' '
FROM
DUMMY
)
UNION ALL
( SELECT
MAP(ROW_NUMBER () OVER (ORDER BY HOST), 1, 'HANA instance memory (allocated)',
' '),
MAP(ROW_NUMBER () OVER (ORDER BY HOST), 1,
LPAD(ROUND(SUM(INSTANCE_TOTAL_MEMORY_ALLOCATED_SIZE) OVER () / 1024 / 1024 / 1024),
9), ' '),
LPAD(ROUND(INSTANCE_TOTAL_MEMORY_ALLOCATED_SIZE / 1024 / 1024 / 1024), 9) || '
(' || HOST || ')',
' '
FROM
M_HOST_RESOURCE_UTILIZATION
 ORDER BY
HOST
)
UNION ALL
( SELECT
' ',
' ',
' ',
' '
FROM
DUMMY
)
UNION ALL
( SELECT
MAP(ROW_NUMBER () OVER (ORDER BY HOST), 1, 'HANA instance memory (peak used)',
' '),
MAP(ROW_NUMBER () OVER (ORDER BY HOST), 1, LPAD(ROUND(T.TOTAL_SIZE / 1024 /
1024 / 1024), 9), ' '),
LPAD(ROUND(MAX(INSTANCE_TOTAL_MEMORY_USED_SIZE) / 1024 / 1024 / 1024), 9) || '
(' || HOST || ')',
' '
FROM
_SYS_STATISTICS.HOST_RESOURCE_UTILIZATION_STATISTICS,
( SELECT
TOP 1 SUM(INSTANCE_TOTAL_MEMORY_USED_SIZE) TOTAL_SIZE
FROM
_SYS_STATISTICS.HOST_RESOURCE_UTILIZATION_STATISTICS
GROUP BY
SNAPSHOT_ID
ORDER BY
SUM(INSTANCE_TOTAL_MEMORY_USED_SIZE) DESC
) T
GROUP BY
T.TOTAL_SIZE,
HOST
ORDER BY
HOST
)
UNION ALL
( SELECT
' ',
' ',
' ',
' '
FROM
DUMMY
)
UNION ALL
( SELECT
MAP(ROW_NUMBER () OVER (ORDER BY HOST), 1, 'HANA instance memory (used)', ' '),
MAP(ROW_NUMBER () OVER (ORDER BY HOST), 1,
LPAD(ROUND(SUM(INSTANCE_TOTAL_MEMORY_USED_SIZE) OVER () / 1024 / 1024 / 1024), 9),
' '),
LPAD(ROUND(INSTANCE_TOTAL_MEMORY_USED_SIZE / 1024 / 1024 / 1024), 9) || ' (' ||
HOST || ')',
' '
FROM
M_HOST_RESOURCE_UTILIZATION
ORDER BY
 HOST
)
UNION ALL
( SELECT
' ',
' ',
' ',
' '
FROM
DUMMY
)
UNION ALL
( SELECT
MAP(ROW_NUMBER () OVER (ORDER BY HOST), 1, 'HANA shared memory', ' '),
MAP(ROW_NUMBER () OVER (ORDER BY HOST), 1,
LPAD(ROUND(SUM(INSTANCE_SHARED_MEMORY_ALLOCATED_SIZE) OVER () / 1024 / 1024 /
1024), 9), ' '),
LPAD(ROUND(INSTANCE_SHARED_MEMORY_ALLOCATED_SIZE / 1024 / 1024 / 1024), 9) || '
(' || HOST || ')',
' '
FROM
M_HOST_RESOURCE_UTILIZATION
ORDER BY
HOST
)
UNION ALL
( SELECT
' ',
' ',
' ',
' '
FROM
DUMMY
)
UNION ALL
( SELECT
NAME,
TOTAL_GB,
DETAIL_GB,
DETAIL2_GB
FROM
( SELECT
MAP(ROW_NUMBER () OVER (ORDER BY HOST, EXCLUSIVE_SIZE_IN_USE DESC), 1, 'HANA
heap memory (used)', ' ') NAME,
MAP(ROW_NUMBER () OVER (ORDER BY HOST, EXCLUSIVE_SIZE_IN_USE DESC), 1,
LPAD(ROUND(SUM(EXCLUSIVE_SIZE_IN_USE) OVER () / 1024 / 1024 / 1024), 9), ' ')
TOTAL_GB,
MAP(ROW_NUMBER () OVER (PARTITION BY HOST ORDER BY EXCLUSIVE_SIZE_IN_USE
DESC), 1,
LPAD(ROUND(SUM(EXCLUSIVE_SIZE_IN_USE) OVER (PARTITION BY HOST) / 1024 /
1024 / 1024), 9) || ' (' || HOST || ')', ' ') DETAIL_GB,
LPAD(ROUND(SUM(EXCLUSIVE_SIZE_IN_USE) / 1024 / 1024 / 1024), 9) || ' (' ||
CATEGORY || ')' DETAIL2_GB,
ROW_NUMBER () OVER (PARTITION BY HOST ORDER BY EXCLUSIVE_SIZE_IN_USE DESC)
ROW_NUM
FROM
( SELECT
HOST,
CATEGORY,
 SUM(EXCLUSIVE_SIZE_IN_USE) EXCLUSIVE_SIZE_IN_USE
FROM
M_HEAP_MEMORY
GROUP BY
HOST,
CATEGORY
)
GROUP BY
HOST,
CATEGORY,
EXCLUSIVE_SIZE_IN_USE
ORDER BY
HOST,
EXCLUSIVE_SIZE_IN_USE DESC
)
WHERE
ROW_NUM <= 10
)
UNION ALL
( SELECT
' ',
' ',
' ',
' '
FROM
DUMMY
)
UNION ALL
( SELECT
NAME,
TOTAL_GB,
DETAIL_GB,
DETAIL2_GB
FROM
( SELECT
MAP(ROW_NUMBER () OVER (ORDER BY HOST, MEMORY_SIZE_IN_TOTAL DESC), 1, 'Column
store size', ' ') NAME,
MAP(ROW_NUMBER () OVER (ORDER BY HOST, MEMORY_SIZE_IN_TOTAL DESC), 1,
LPAD(ROUND(SUM(MEMORY_SIZE_IN_TOTAL) OVER () / 1024 / 1024 / 1024), 9), ' ')
TOTAL_GB,
MAP(ROW_NUMBER () OVER (PARTITION BY HOST ORDER BY MEMORY_SIZE_IN_TOTAL
DESC), 1,
LPAD(ROUND(SUM(MEMORY_SIZE_IN_TOTAL) OVER (PARTITION BY HOST) / 1024 / 1024
/ 1024), 9) || ' (' || HOST || ')', ' ') DETAIL_GB,
LPAD(ROUND(SUM(MEMORY_SIZE_IN_TOTAL) / 1024 / 1024 / 1024), 9) || ' (' ||
TABLE_NAME || ')' DETAIL2_GB,
ROW_NUMBER () OVER (PARTITION BY HOST ORDER BY MEMORY_SIZE_IN_TOTAL DESC)
ROW_NUM,
ROUND(SUM(MEMORY_SIZE_IN_TOTAL) / 1024 / 1024 / 1024) TABLE_SIZE_GB
FROM
( SELECT
HOST,
TABLE_NAME,
SUM(MEMORY_SIZE_IN_TOTAL) MEMORY_SIZE_IN_TOTAL
FROM
M_CS_TABLES
GROUP BY
HOST,
TABLE_NAME
 )
GROUP BY
HOST,
TABLE_NAME,
MEMORY_SIZE_IN_TOTAL
ORDER BY
HOST,
MEMORY_SIZE_IN_TOTAL DESC
)
WHERE
TABLE_SIZE_GB > 0 AND
ROW_NUM <= 10
)
UNION ALL
( SELECT
' ',
' ',
' ',
' '
FROM
DUMMY
)
UNION ALL
( SELECT
MAP(ROW_NUM_GLOBAL, 1, NAME, ' ') NAME,
MAP(ROW_NUM_GLOBAL, 1, TOTAL_GB, ' ') TOTAL_GB,
DETAIL_GB,
DETAIL2_GB
FROM
( SELECT
'Row store size' NAME,
LPAD(ROUND(AVG(R.ROW_STORE_USED_SIZE) OVER () / 1024 / 1024 / 1024), 9)
TOTAL_GB,
MAP(ROW_NUMBER () OVER (PARTITION BY HOST ORDER BY SUM(T.TABLE_SIZE) DESC),
1,
LPAD(ROUND(SUM(SUM(TABLE_SIZE)) OVER (PARTITION BY HOST) / 1024 / 1024 /
1024), 9) || ' (' || HOST || ')', ' ') DETAIL_GB,
LPAD(ROUND(SUM(TABLE_SIZE) / 1024 / 1024 / 1024), 9) || ' (' || TABLE_NAME ||
')' DETAIL2_GB,
ROW_NUMBER () OVER (PARTITION BY HOST ORDER BY SUM(TABLE_SIZE) DESC) ROW_NUM,
ROW_NUMBER () OVER (ORDER BY SUM(TABLE_SIZE) DESC) ROW_NUM_GLOBAL,
ROUND(SUM(TABLE_SIZE) / 1024 / 1024 / 1024) TABLE_SIZE_GB
FROM
( SELECT
HOST,
TABLE_NAME,
ALLOCATED_FIXED_PART_SIZE + ALLOCATED_VARIABLE_PART_SIZE TABLE_SIZE
FROM
M_RS_TABLES
UNION ALL
( SELECT
HOST,
TABLE_NAME,
INDEX_SIZE TABLE_SIZE
FROM
M_RS_INDEXES
)
) T,
( SELECT SUM(USED_SIZE) ROW_STORE_USED_SIZE FROM M_RS_MEMORY ) R
 GROUP BY
T.HOST,
T.TABLE_NAME,
R.ROW_STORE_USED_SIZE
ORDER BY
SUM(T.TABLE_SIZE) DESC
)
WHERE
TABLE_SIZE_GB > 0 AND
ROW_NUM <= 10
)
UNION ALL
( SELECT TOP 1
' ',
' ',
' ',
' '
FROM
M_LIVECACHE_CONTAINER_STATISTICS
)
UNION ALL
( SELECT
MAP(ROW_NUM_GLOBAL, 1, NAME, ' ') NAME,
MAP(ROW_NUM_GLOBAL, 1, TOTAL_GB, ' ') TOTAL_GB,
DETAIL_GB,
DETAIL2_GB
FROM
( SELECT
'liveCache size' NAME,
LPAD(ROUND(SUM(SUM(PAGE_SIZE_BYTE)) OVER () / 1024 / 1024 / 1024), 9)
TOTAL_GB,
MAP(ROW_NUMBER () OVER (PARTITION BY HOST ORDER BY SUM(PAGE_SIZE_BYTE) DESC),
1,
LPAD(ROUND(SUM(SUM(PAGE_SIZE_BYTE)) OVER (PARTITION BY HOST) / 1024 /
1024 / 1024), 9) || ' (' || HOST || ')', ' ') DETAIL_GB,
LPAD(ROUND(SUM(PAGE_SIZE_BYTE) / 1024 / 1024 / 1024), 9) || ' (' ||
OMS_CLASS_NAME || ')' DETAIL2_GB,
ROW_NUMBER () OVER (PARTITION BY HOST ORDER BY SUM(PAGE_SIZE_BYTE) DESC)
ROW_NUM,
ROW_NUMBER () OVER (ORDER BY SUM(PAGE_SIZE_BYTE) DESC) ROW_NUM_GLOBAL,
ROUND(SUM(PAGE_SIZE_BYTE) / 1024 / 1024 / 1024) CONTAINER_SIZE_GB
FROM
( SELECT
HOST,
OMS_CLASS_NAME,
SUM(PAGE_SIZE_SUM) PAGE_SIZE_BYTE
FROM
M_LIVECACHE_CONTAINER_STATISTICS
GROUP BY
HOST,
OMS_CLASS_NAME
)
GROUP BY
HOST,
OMS_CLASS_NAME
ORDER BY
SUM(PAGE_SIZE_BYTE) DESC
)
WHERE
 CONTAINER_SIZE_GB > 0 AND
ROW_NUM <= 10
)
UNION ALL
( SELECT
' ',
' ',
' ',
' '
FROM
DUMMY
)
UNION ALL
( SELECT
NAME,
TOTAL_GB,
DETAIL_GB,
DETAIL2_GB
FROM
( SELECT
MAP(ROW_NUMBER () OVER (ORDER BY SUM(TP.TABLE_SIZE) DESC), 1, 'Disk size', '
') NAME,
MAP(ROW_NUMBER () OVER (ORDER BY SUM(TP.TABLE_SIZE) DESC), 1,
LPAD(ROUND(SUM(TP.TABLE_SIZE) OVER () / 1024 / 1024 / 1024), 9), ' ') TOTAL_GB,
MAP(ROW_NUMBER () OVER (ORDER BY SUM(TP.TABLE_SIZE) DESC), 1,
LPAD(ROUND(SUM(TP.TABLE_SIZE) OVER () / 1024 / 1024 / 1024), 9) || '
(global)', ' ') DETAIL_GB,
LPAD(ROUND(TP.TABLE_SIZE / 1024 / 1024 / 1024), 9) || ' (' || TP.TABLE_NAME
|| ')' DETAIL2_GB,
ROW_NUMBER () OVER (ORDER BY TP.TABLE_SIZE DESC) ROW_NUM,
ROUND(TP.TABLE_SIZE / 1024 / 1024 / 1024) TABLE_SIZE_GB
FROM
( SELECT
TABLE_NAME,
SUM(DISK_SIZE) TABLE_SIZE
FROM
M_TABLE_PERSISTENCE_STATISTICS
GROUP BY
TABLE_NAME
) TP
GROUP BY
TP.TABLE_NAME,
TP.TABLE_SIZE
ORDER BY
SUM(TP.TABLE_SIZE) DESC
)
WHERE
TABLE_SIZE_GB > 0 AND
ROW_NUM <= 10
)