Data Explorer: Request profiles one at a time for larger tables (#9096)

These are some changes to make profile rendering a little smoother.
Before we were batching 4 profiles at a time, but this changes to
1-at-a-time for over 1 million rows (below that they the in-window
profiles are requested in a single big batch):

I also noticed that the background task queue in Python was using 5 x #
CPUs by default and for compute heavy profile computation this can
result in inefficient context switching when computing many profiles.
Now the number of workers is equal to the number of logical CPU cores.

Author: wesm

extensions/positron-python/python_files/posit/positron/utils.py

@@ -9,6 +9,7 @@
 import inspect
 import json
 import logging
+import os
 import re
 import sys
 import threading
@@ -149,7 +150,9 @@ class BackgroundJobQueue:
 
     def __init__(self, max_workers=None):
         # Initialize the ThreadPoolExecutor with the specified number
-        # of workers
+        # of workers. Default to the number of CPU cores for optimal performance.
+        if max_workers is None:
+            max_workers = os.cpu_count() or 4
         self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=max_workers)
         self.pending_futures = set()
         self.lock = threading.Lock()

src/vs/workbench/services/positronDataExplorer/common/tableSummaryCache.ts

@@ -21,6 +21,7 @@ const SMALL_HISTOGRAM_NUM_BINS = 80;
 const LARGE_HISTOGRAM_NUM_BINS = 200;
 const SMALL_FREQUENCY_TABLE_LIMIT = 8;
 const LARGE_FREQUENCY_TABLE_LIMIT = 16;
+const UPDATE_EVENT_DEBOUNCE_DELAY = 50;
 
 /**
  * UpdateDescriptor interface.
@@ -54,6 +55,11 @@ export class TableSummaryCache extends Disposable {
 	 */
 	private _trimCacheTimeout?: Timeout;
 
+	/**
+	 * Gets or sets the debounced update event timeout.
+	 */
+	private _debouncedUpdateTimeout?: Timeout;
+
 	/**
 	 * The search text used to filter the dataset in the column schema
 	 * and column profile caches. The last search text value is maintained
@@ -146,6 +152,9 @@ export class TableSummaryCache extends Disposable {
 		// Clear the trim cache timeout.
 		this.clearTrimCacheTimeout();
 
+		// Clear the debounced update timeout.
+		this.clearDebouncedUpdateTimeout();
+
 		// Call the base class's dispose method.
 		super.dispose();
 	}
@@ -676,27 +685,36 @@ export class TableSummaryCache extends Disposable {
 
 		const tableState = await this._dataExplorerClientInstance.getBackendState();
 
-		// For more than 10 million rows, we request profiles one by one rather than as a batch for
+		// For more than 1 million rows, we request profiles one by one rather than as a batch for
 		// better responsiveness
-		const BATCHING_THRESHOLD = 5_000_000;
+		const BATCHING_THRESHOLD = 1_000_000;
 		if (tableState.table_shape.num_rows > BATCHING_THRESHOLD) {
-			const BATCH_SIZE = 4;
-			for (let i = 0; i < columnIndices.length; i += BATCH_SIZE) {
-				// Get the next batch of up to 4 requests
-				const batchColumnRequests = columnRequests.slice(i, i + BATCH_SIZE);
-				const batchColumnIndices = columnIndices.slice(i, i + BATCH_SIZE);
-
-				// Send the batch of requests to getColumnProfiles
-				const results = await this._dataExplorerClientInstance.getColumnProfiles(batchColumnRequests);
-
-				// Cache the returned column profiles for each index in the batch
-				for (let j = 0; j < results.length; j++) {
-					this._columnProfileCache.set(batchColumnIndices[j], results[j]);
-				}
+			// Start all requests and store promises
+			const profilePromises = columnRequests.map((columnRequest, index) => {
+				const columnIndex = columnIndices[index];
+
+				// Start the request and handle result immediately when it completes
+				const promise = this._dataExplorerClientInstance.getColumnProfiles([columnRequest])
+					.then(results => {
+						// Cache the result as soon as it's available
+						if (results.length > 0) {
+							this._columnProfileCache.set(columnIndex, results[0]);
+						}
+						// Fire the onDidUpdate event with debouncing for smoother updates
+						this.fireOnDidUpdateDebounced();
+						return results;
+					})
+					.catch(error => {
+						// Handle errors gracefully
+						console.error(`Failed to get column profile for index ${columnIndex}:`, error);
+						throw error;
+					});
+
+				return promise;
+			});
 
-				// Fire the onDidUpdate event so things update as soon as they are returned
-				this._onDidUpdateEmitter.fire();
-			}
+			// Wait for all requests to complete
+			await Promise.allSettled(profilePromises);
 		} else {
 			// Load the column profiles as a batch
 			const columnProfileResults = await this._dataExplorerClientInstance.getColumnProfiles(
@@ -764,6 +782,31 @@ export class TableSummaryCache extends Disposable {
 		}
 	}
 
+	/**
+	 * Clears the debounced update timeout.
+	 */
+	private clearDebouncedUpdateTimeout() {
+		// If there is a debounced update timeout scheduled, clear it.
+		if (this._debouncedUpdateTimeout) {
+			clearTimeout(this._debouncedUpdateTimeout);
+			this._debouncedUpdateTimeout = undefined;
+		}
+	}
+
+	/**
+	 * Fires the onDidUpdate event with debouncing to smooth incremental updates.
+	 */
+	private fireOnDidUpdateDebounced() {
+		// Clear any existing debounced update timeout.
+		this.clearDebouncedUpdateTimeout();
+
+		// Set a new debounced update timeout.
+		this._debouncedUpdateTimeout = setTimeout(() => {
+			this._debouncedUpdateTimeout = undefined;
+			this._onDidUpdateEmitter.fire();
+		}, UPDATE_EVENT_DEBOUNCE_DELAY);
+	}
+
 	/**
 	 * Trims the data in the cache if the key is not in the provided list.
 	 * @param columnIndicesToKeep The array of column indices to keep in the cache.