Move allocations event to CPU class

Author: ildus

Diff for: contrib/pg_stat_wait/pg_stat_wait.c

@@ -91,7 +91,7 @@ pg_wait_class_list(PG_FUNCTION_ARGS)
 		TupleDesc			tupdesc;
 
 		funcctx = SRF_FIRSTCALL_INIT();
-		funcctx->max_calls = WAITS_COUNT - 1;
+		funcctx->max_calls = WAITS_COUNT;
 
 		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
@@ -119,7 +119,7 @@ pg_wait_class_list(PG_FUNCTION_ARGS)
 		MemSet(values, 0, sizeof(values));
 		MemSet(nulls, 0, sizeof(nulls));
 
-		idx = funcctx->call_cntr + 1;
+		idx = funcctx->call_cntr;
 		values[0] = Int32GetDatum(idx);
 		values[1] = CStringGetDatum(WAIT_CLASSES[idx]);
 
@@ -163,7 +163,6 @@ pg_wait_event_list(PG_FUNCTION_ARGS)
 		funcctx->tuple_desc = BlessTupleDesc(tupdesc);
 		funcctx->user_fctx = palloc0(sizeof(WaitEventContext));
 
-		((WaitEventContext *)funcctx->user_fctx)->class_cnt = 1;
 		MemoryContextSwitchTo(oldcontext);
 	}
 
@@ -185,7 +184,9 @@ pg_wait_event_list(PG_FUNCTION_ARGS)
 		values[1] = Int32GetDatum(ctx->event_cnt);
 		values[2] = CStringGetDatum(WaitsEventName(ctx->class_cnt, ctx->event_cnt));
 
-		if (ctx->class_cnt == WAIT_LWLOCK && ctx->event_cnt < (LWLockTranchesCount()-1))
+		if (ctx->class_cnt == WAIT_CPU && ctx->event_cnt < (WAIT_CPU_EVENTS_COUNT-1))
+			ctx->event_cnt++;
+		else if (ctx->class_cnt == WAIT_LWLOCK && ctx->event_cnt < (LWLockTranchesCount()-1))
 			ctx->event_cnt++;
 		else if (ctx->class_cnt == WAIT_LOCK && ctx->event_cnt < (WAIT_LOCKS_COUNT-1))
 			ctx->event_cnt++;
@@ -456,7 +457,7 @@ pg_stat_wait_get_profile(PG_FUNCTION_ARGS)
 
 		if (params->eventIdx == WAIT_EVENTS_COUNT)
 		{
-			params->classIdx = WAIT_LWLOCK;
+			params->classIdx = 0;
 			params->eventIdx = 0;
 			params->backendIdx++;
 			Assert(params->backendIdx <= MaxBackends);

Diff for: src/backend/storage/lmgr/wait.c

@@ -21,13 +21,17 @@ int   WaitsFlushPeriod;
 
 const char *WAIT_CLASSES[] =
 {
-	"",
+	"CPU",
 	"LWLocks",
 	"Locks",
 	"Storage",
 	"Latch",
-	"Network",
-	"Allocations"
+	"Network"
+};
+
+const char *WAIT_CPU_NAMES[] =
+{
+	"MemAllocation"
 };
 
 const char *WAIT_IO_NAMES[] =
@@ -52,13 +56,12 @@ const char *WAIT_NETWORK_NAMES[] =
 
 const int WAIT_OFFSETS[] =
 {
-	0, /* skip */
+	WAIT_CPU_OFFSET,
 	WAIT_LWLOCKS_OFFSET,
 	WAIT_LOCKS_OFFSET,
 	WAIT_IO_OFFSET,
 	WAIT_LATCH_OFFSET,
-	WAIT_NETWORK_OFFSET,
-	WAIT_ALLOC_OFFSET
+	WAIT_NETWORK_OFFSET
 };
 
 /* Returns event name for wait */
@@ -68,11 +71,11 @@ WaitsEventName(int classId, int eventId)
 	static char *empty = "";
 	switch (classId)
 	{
+		case WAIT_CPU: return WAIT_CPU_NAMES[eventId];
 		case WAIT_LOCK: return LOCK_NAMES[eventId];
 		case WAIT_LWLOCK: return LWLOCK_TRANCHE_NAME(eventId);
 		case WAIT_IO: return WAIT_IO_NAMES[eventId];
 		case WAIT_NETWORK: return WAIT_NETWORK_NAMES[eventId];
-		case WAIT_ALLOC: /* fallthrough */;
 		case WAIT_LATCH: return WAIT_CLASSES[classId];
 	};
 	return empty;
@@ -232,8 +235,6 @@ StartWait(int classId, int eventId, int p1, int p2, int p3, int p4, int p5)
 	ProcWaits		         *waits;
 	ProcWait		         *curwait;
 
-	Assert(classId > 0 && classId < WAITS_COUNT);
-
 	if (!MyProc || !WaitsInitialized)
 		return;
 

Diff for: src/backend/utils/mmgr/aset.c

@@ -496,7 +496,7 @@ AllocSetContextCreate(MemoryContext parent,
 		Size		blksize = MAXALIGN(minContextSize);
 		AllocBlock	block;
 
-		WAIT_START(WAIT_ALLOC, 0, 0, 0, 0, 0, 0);
+		WAIT_START(WAIT_CPU, WAIT_MALLOC, 0, 0, 0, 0, 0);
 		block = (AllocBlock) malloc(blksize);
 		WAIT_STOP();
 		if (block == NULL)
@@ -677,7 +677,7 @@ AllocSetAlloc(MemoryContext context, Size size)
 	{
 		chunk_size = MAXALIGN(size);
 		blksize = chunk_size + ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ;
-		WAIT_START(WAIT_ALLOC, 0, 0, 0, 0, 0, 0);
+		WAIT_START(WAIT_CPU, WAIT_MALLOC, 0, 0, 0, 0, 0);
 		block = (AllocBlock) malloc(blksize);
 		WAIT_STOP();
 		if (block == NULL)
@@ -860,7 +860,7 @@ AllocSetAlloc(MemoryContext context, Size size)
 			blksize <<= 1;
 
 		/* Try to allocate it */
-		WAIT_START(WAIT_ALLOC, 0, 0, 0, 0, 0, 0);
+		WAIT_START(WAIT_CPU, WAIT_MALLOC, 0, 0, 0, 0, 0);
 		block = (AllocBlock) malloc(blksize);
 
 		/*

Diff for: src/include/storage/wait.h

@@ -22,25 +22,33 @@
 
    Monitored waits by now:
 
-   1) Heavy-weight locks (lock.c)
-   2) LW-Locks (lwlock.c)
-   3) IO read-write (md.c)
-   4) Network (be-secure.c)
-   5) Latches (pg_latch.c)
+   1) CPU events. For now it is on memory chunks allocation
+   2) Heavy-weight locks (lock.c)
+   3) LW-Locks (lwlock.c)
+   4) IO read-write (md.c)
+   5) Network (be-secure.c)
+   6) Latches (pg_latch.c)
  */
 
 enum WaitClasses
 {
-	WAIT_LWLOCK = 1,
+	WAIT_CPU,
+	WAIT_LWLOCK,
 	WAIT_LOCK,
 	WAIT_IO,
 	WAIT_LATCH,
 	WAIT_NETWORK,
-	WAIT_ALLOC,
 	/* Last item as count */
 	WAITS_COUNT
 } WaitClasses;
 
+enum WaitCPUEvents
+{
+	WAIT_MALLOC,
+	/* Last item as count */
+	WAIT_CPU_EVENTS_COUNT
+} WaitCPUEvents;
+
 enum WaitIOEvents
 {
 	WAIT_SMGR_READ,
@@ -69,13 +77,13 @@ enum WaitNetworkEvents
 #define WAIT_LOCKS_COUNT           (LOCKTAG_LAST_TYPE + 1)
 
 /* Waits in arrays in backends and in shared memory located by offsets */
-#define WAIT_LWLOCKS_OFFSET  0
+#define WAIT_CPU_OFFSET 0
+#define WAIT_LWLOCKS_OFFSET  (WAIT_CPU_OFFSET + WAIT_CPU_EVENTS_COUNT)
 #define WAIT_LOCKS_OFFSET    (WAIT_LWLOCKS_OFFSET + WAIT_LWLOCKS_COUNT)
 #define WAIT_IO_OFFSET       (WAIT_LOCKS_OFFSET + WAIT_LOCKS_COUNT)
 #define WAIT_LATCH_OFFSET    (WAIT_IO_OFFSET + WAIT_IO_EVENTS_COUNT)
 #define WAIT_NETWORK_OFFSET  (WAIT_LATCH_OFFSET + 1)
-#define WAIT_ALLOC_OFFSET    (WAIT_NETWORK_OFFSET + WAIT_NETWORK_EVENTS_COUNT)
-#define WAIT_EVENTS_COUNT    (WAIT_ALLOC_OFFSET + 1)
+#define WAIT_EVENTS_COUNT    (WAIT_NETWORK_OFFSET + WAIT_NETWORK_EVENTS_COUNT)
 
 #define WAIT_START(classId, eventId, p1, p2, p3, p4, p5) \
 	do { \