PGPRO-791: Fix prioritization

Author: za-arthur

src/backend/tcop/priority.c

@@ -127,8 +127,8 @@ calculate_cpu_usage(int32 sleep_prev, int32 sleep_diff)
 	priority_sum = pg_atomic_read_u32(&PriorityWorkerState->cpu_priority_sum);
 
 	if (ru_spent_actual == 0 || spent_sum == 0 || priority_sum == 0 ||
-		session_interrupt_count == 0 /*||
-		session_cpu_weight == pg_atomic_read_u32(&PriorityWorkerState->cpu_priority_max)*/)
+		session_interrupt_count == 0 ||
+		session_cpu_weight == pg_atomic_read_u32(&PriorityWorkerState->cpu_priority_max))
 	{
 		ru_spent_prev = 0;
 		return 0;
@@ -137,18 +137,19 @@ calculate_cpu_usage(int32 sleep_prev, int32 sleep_diff)
 	/* Calculate total time to sleep */
 	ru_spent_need = session_cpu_weight * spent_sum / priority_sum * 1.1;
 
-	if (sleep_diff != 0)
+	if (sleep_diff != 0 && ru_spent_actual != ru_spent_prev)
 	{
 		int64		ru_diff,
+					ru_diff_need,
 					impact,
 					res;
-		float8		factor;
 
 		ru_diff = (int64) ru_spent_actual - (int64) ru_spent_prev;
 		if (ru_diff < 0)
 			ru_diff *= -1;
-		factor = (ru_diff != 0) ? (float8) (sleep_diff / ru_diff) : 0;
-		impact = (int) ((int) (ru_spent_actual - ru_spent_need) * factor);
+
+		ru_diff_need = ru_spent_actual - ru_spent_need;
+		impact = (int64) (ru_diff_need * sleep_diff / ru_diff);
 
 		res = sleep_prev + impact;
 		if (res > PG_INT32_MAX || res < PG_INT32_MIN || res < 0)
@@ -162,18 +163,15 @@ calculate_cpu_usage(int32 sleep_prev, int32 sleep_diff)
 			sleep_need = (ru_spent_actual > ru_spent_need) ?
 				sleep_prev * 1.1 : sleep_prev * 0.9;
 		else
-		{
 			sleep_need = (ru_spent_actual > ru_spent_need) ?
-				(ru_spent_actual - ru_spent_need) : 0;
-			elog(LOG, UINT64_FORMAT, ru_spent_actual - ru_spent_need);
-		}
+				(int32) (ru_spent_actual - ru_spent_need) : 0;
 	}
 
 	ru_spent_prev = ru_spent_actual;
 
-	elog(LOG, "- %d - cpu, %d, %d, " UINT64_FORMAT ", " UINT64_FORMAT,
-		 session_cpu_weight, sleep_need, sleep_prev,
-		 ru_spent_actual, ru_spent_need);
+//	elog(LOG, "- %d - cpu, %d, %d, " UINT64_FORMAT ", " UINT64_FORMAT,
+//		 session_cpu_weight, sleep_need, sleep_prev,
+//		 ru_spent_actual, ru_spent_need);
 
 	return sleep_need;
 }
@@ -220,19 +218,19 @@ calculate_ioread_usage(int32 sleep_prev, int32 sleep_diff)
 	/* Calculate total time to sleep */
 	blks_read_need = session_ioread_weight * read_sum / priority_sum * 1.1;
 
-	if (sleep_diff != 0)
+	if (sleep_diff != 0 && blks_read_actual != blks_read_prev)
 	{
 		int64		read_diff,
+					read_diff_need,
 					impact,
 					res;
-		float8		factor;
 
 		read_diff = (int64) blks_read_actual - (int64) blks_read_prev;
 		if (read_diff < 0)
 			read_diff *= -1;
-		factor = (read_diff != 0) ? (float8) (sleep_diff / read_diff) : 0;
 
-		impact = (int) ((int) (blks_read_actual - blks_read_need) * factor);
+		read_diff_need = blks_read_actual - blks_read_need;
+		impact = (int64) (read_diff_need * sleep_diff / read_diff);
 
 		res = sleep_prev + impact;
 
@@ -247,18 +245,15 @@ calculate_ioread_usage(int32 sleep_prev, int32 sleep_diff)
 			sleep_need = (blks_read_actual > blks_read_need) ?
 				sleep_prev * 1.1 : sleep_prev * 0.9;
 		else
-		{
 			sleep_need = (blks_read_actual > blks_read_need) ?
-				(blks_read_actual - blks_read_need) / 30 : 0;
-			elog(LOG, UINT64_FORMAT, blks_read_actual - blks_read_need);
-		}
+				(int32) (blks_read_actual - blks_read_need) / 30 : 0;
 	}
 
 	blks_read_prev = blks_read_actual;
 
-	elog(LOG, "- %d - ioread, %d, %d, " UINT64_FORMAT ", " UINT64_FORMAT,
-		 session_ioread_weight, sleep_need, sleep_prev,
-		 blks_read_actual, blks_read_need);
+//	elog(LOG, "- %d - ioread, %d, %d, " UINT64_FORMAT ", " UINT64_FORMAT,
+//		 session_ioread_weight, sleep_need, sleep_prev,
+//		 blks_read_actual, blks_read_need);
 
 	return sleep_need;
 }
@@ -305,19 +300,19 @@ calculate_iowrite_usage(int32 sleep_prev, int32 sleep_diff)
 	/* Calculate total time to sleep */
 	blks_write_need = session_iowrite_weight * write_sum / priority_sum * 1.1;
 
-	if (sleep_diff != 0)
+	if (sleep_diff != 0 && blks_write_actual != blks_write_prev)
 	{
 		int64		write_diff,
+					write_diff_need,
 					impact,
 					res;
-		float8		factor;
 
 		write_diff = (int64) blks_write_actual - (int64) blks_write_prev;
 		if (write_diff < 0)
 			write_diff *= -1;
-		factor = (write_diff != 0) ? (float8) (sleep_diff / write_diff) : 0;
 
-		impact = (int) ((int) (blks_write_actual - blks_write_need) * factor);
+		write_diff_need = blks_write_actual - blks_write_need;
+		impact = (int64) (write_diff_need * sleep_diff / write_diff);
 
 		res = sleep_prev + impact;
 
@@ -333,14 +328,14 @@ calculate_iowrite_usage(int32 sleep_prev, int32 sleep_diff)
 				sleep_prev * 1.1 : sleep_prev * 0.9;
 		else
 			sleep_need = (blks_write_actual > blks_write_need) ?
-				(blks_write_actual - blks_write_need) / 30 : 0;
+				(int32) (blks_write_actual - blks_write_need) / 10 : 0;
 	}
 
 	blks_write_prev = blks_write_actual;
 
-	elog(LOG, "- %d - iowrite, %d, %d, " UINT64_FORMAT ", " UINT64_FORMAT,
-		 session_iowrite_weight, sleep_need, sleep_prev,
-		 blks_write_actual, blks_write_need);
+//	elog(LOG, "- %d - iowrite, %d, %d, " UINT64_FORMAT ", " UINT64_FORMAT,
+//		 session_iowrite_weight, sleep_need, sleep_prev,
+//		 blks_write_actual, blks_write_need);
 
 	return sleep_need;
 }
@@ -381,7 +376,7 @@ SessionUsageTimeoutHandler(void)
 
 	session_interrupt_count = 0;
 
-	/* Re-enable timeout if priorities are enable */
+	/* Re-enable timeout if prioritization is enabled */
 	if (usage_tracking_interval && session_usage_timeout_enabled)
 		enable_timeout_after(SESSION_USAGE_TIMEOUT,
 							 usage_tracking_interval * 1000);