Tuning SQL Server on Linux: What Microsoft recommends and what actually helps

#!/usr/bin/env bash
# PSG Stack · SQL Server on Linux and Docker · Host check
# Compares the Linux settings of a SQL Server host with Microsoft's recommendations
# (Learn: "Performance best practices: Storage, kernel, CPU, and network", as of 05/2026).
#
# !!! WARNING — please read before running !!!
# - Read-only. The script changes no setting and writes no file.
# - Usage: bash host-check-en.sh [data directory] [log directory]
#   Default: /var/opt/mssql/data for both. Without root, single values may be missing (shown as "?").
# - Kernel values apply to the whole host. Inside a container the script shows the host's values;
#   they can only be changed on the host, not in the container.
# - "check" means: different from Microsoft's recommendation. Whether the difference costs you anything
#   is not something the script can tell; the recommendations apply to dedicated SQL Server hosts.
# - Tested in the PSG lab on Ubuntu 24.04 (host) and in the containers of SQL Server 2017 to 2025
#   (13 Nov 2026); not tested on Red Hat or SUSE.
set -u
DATA=${1:-/var/opt/mssql/data}
LOG=${2:-$DATA}
rd() { cat "$1" 2>/dev/null | tr -d '\n' || true; }
row() { printf '%-34s %-28s %-30s %s\n' "$1" "$2" "$3" "$4"; }
cmp() { if [ "$1" = "$2" ]; then echo ok; elif [ -z "$1" ] || [ "$1" = "?" ]; then echo "?"; else echo check; fi; }

echo "Host check SQL Server on Linux · $(date '+%Y-%m-%d %H:%M') · $(hostname)"
. /etc/os-release 2>/dev/null; echo "System: ${PRETTY_NAME:-?} · kernel $(uname -r)"
if [ -f /.dockerenv ] || grep -qa docker /proc/1/cgroup 2>/dev/null; then echo "Note: running in a container; kernel values are the host's."; fi
echo
row "Setting" "Current" "Recommended (Microsoft)" "Rating"
row "-------" "-------" "-----------------------" "------"

thp=$(rd /sys/kernel/mm/transparent_hugepage/enabled | sed -n 's/.*\[\(.*\)\].*/\1/p'); thp=${thp:-?}
row "Transparent Huge Pages" "$thp" "always (several instances: madvise)" "$(cmp "$thp" always)"
sw=$(rd /proc/sys/vm/swappiness); sw=${sw:-?}
row "vm.swappiness" "$sw" "1" "$(cmp "$sw" 1)"
mm=$(rd /proc/sys/vm/max_map_count); mm=${mm:-?}
if [ "$mm" != "?" ] && [ "$mm" -ge 262144 ] 2>/dev/null; then b=ok; [ "$mm" -lt 1600000 ] && b="ok (profile: 1600000)"; else b=$(cmp "$mm" 1600000); fi
row "vm.max_map_count" "$mm" "1600000 (at least 262144)" "$b"
dr=$(rd /proc/sys/vm/dirty_ratio); dbr=$(rd /proc/sys/vm/dirty_background_ratio)
row "vm.dirty_ratio / background" "${dr:-?} / ${dbr:-?}" "80 / 3 (TuneD profile mssql)" "$( [ "${dr:-}" = 80 ] && [ "${dbr:-}" = 3 ] && echo ok || echo check )"
numa=$(ls -d /sys/devices/system/node/node* 2>/dev/null | wc -l)
nb=$(rd /proc/sys/kernel/numa_balancing); nb=${nb:-?}
if [ "$numa" -gt 1 ]; then b=$(cmp "$nb" 0); else b="ok (1 NUMA node)"; fi
row "kernel.numa_balancing" "$nb ($numa NUMA nodes)" "0 with several NUMA nodes" "$b"
if command -v tuned-adm >/dev/null 2>&1; then t=$(tuned-adm active 2>/dev/null | sed -n 's/.*: //p'); else t="no TuneD"; fi
row "TuneD profile" "${t:-?}" "mssql" "$( [ "${t:-}" = mssql ] && echo ok || echo check )"
gov=$(rd /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor); gov=${gov:-"n/a (VM?)"}
row "CPU governor" "$gov" "performance" "$( [ "$gov" = performance ] && echo ok || { [ "${gov#n/a}" != "$gov" ] && echo info || echo check; } )"
sw_on=$(awk 'NR>1' /proc/swaps 2>/dev/null | wc -l)
row "Swap configured" "$( [ "$sw_on" -gt 0 ] && echo yes || echo no )" "yes (safety net, not capacity)" "$( [ "$sw_on" -gt 0 ] && echo ok || echo check )"

for dir in $(printf "%s\n%s\n" "$DATA" "$LOG" | awk '!s[$0]++'); do
  [ -d "$dir" ] || { row "Directory $dir" "missing" "" "?"; continue; }
  read -r dev fs opts < <(awk -v p="$(df -P "$dir" 2>/dev/null | awk 'NR==2{print $6}')" '$2==p{print $1, $3, $4}' /proc/mounts | tail -1)
  if [ "${fs:-}" = overlay ]; then
    row "File system $dir" "overlay" "volume or bind mount" "check (container writable layer)"; continue; fi
  row "File system $dir" "${fs:-?}" "xfs (ext4 supported)" "$( [ "${fs:-}" = xfs ] && echo ok || { [ "${fs:-}" = ext4 ] && echo ok || echo check; } )"
  row "  Mount option atime" "$(echo "${opts:-?}" | grep -o 'noatime\|relatime\|strictatime' | head -1)" "noatime" "$(echo "${opts:-}" | grep -q noatime && echo ok || echo check)"
  blk=$(basename "$(readlink -f "${dev:-x}" 2>/dev/null)" | sed 's/[0-9]*$//; s/p$//')
  if [ -n "$blk" ] && [ -d "/sys/block/$blk/queue" ]; then
    ra=$(rd /sys/block/$blk/queue/read_ahead_kb); sch=$(rd /sys/block/$blk/queue/scheduler | sed -n 's/.*\[\(.*\)\].*/\1/p')
    fua=$(rd /sys/block/$blk/queue/fua); wc=$(rd /sys/block/$blk/queue/write_cache)
    row "  Read-ahead ($blk)" "${ra:-?} KB" "4096 (blockdev --setra, sectors)" "info"
    row "  I/O scheduler ($blk)" "${sch:-?}" "no value given (multiqueue)" "info"
    row "  FUA / write cache ($blk)" "${fua:-?} / ${wc:-?}" "only with FUA=1 trace flag 3979" "info"
  else
    row "  Block device" "not determinable" "" "?"
  fi
done

CONF=/var/opt/mssql/mssql.conf
echo
if [ -r "$CONF" ]; then
  echo "mssql.conf ($CONF), entries relevant for performance:"
  grep -E '^\s*(writethrough|alternatewritethrough|memorylimitmb|traceflag[0-9]*)\s*=' "$CONF" | sed 's/^/  /' || echo "  (none; defaults apply)"
else
  echo "mssql.conf not readable or not present (defaults apply; in a container possibly MSSQL_* variables)."
fi
echo "Linux default: forced flush (trace flag 3982), control.writethrough = 1, control.alternatewritethrough = 1."
echo "Never set writethrough = 0 unless it is proven that the storage is O_DIRECT safe."

Host check SQL Server on Linux · 2026-11-13 10:33 · psg-sql-lab01
System: Ubuntu 24.04.5 LTS · kernel 6.8.0-147-generic

Setting                            Current                      Recommended (Microsoft)        Rating
-------                            -------                      -----------------------        ------
Transparent Huge Pages             madvise                      always (several instances: madvise) check
vm.swappiness                      60                           1                              check
vm.max_map_count                   1048576                      1600000 (at least 262144)      ok (profile: 1600000)
vm.dirty_ratio / background        20 / 10                      80 / 3 (TuneD profile mssql)   check
kernel.numa_balancing              1 (2 NUMA nodes)             0 with several NUMA nodes      check
TuneD profile                      no TuneD                     mssql                          check
CPU governor                       n/a (VM?)                    performance                    info
Swap configured                    no                           yes (safety net, not capacity) check
File system /srv/sql/data          ext4                         xfs (ext4 supported)           ok
  Mount option atime               relatime                     noatime                        check
  Read-ahead (sdc)                 128 KB                       4096 (blockdev --setra, sectors) info
  I/O scheduler (sdc)              none                         no value given (multiqueue)    info
  FUA / write cache (sdc)          0 / write back               only with FUA=1 trace flag 3979 info
File system /srv/sql/log           ext4                         xfs (ext4 supported)           ok
  Mount option atime               relatime                     noatime                        check
  Read-ahead (sdd)                 128 KB                       4096 (blockdev --setra, sectors) info
  I/O scheduler (sdd)              none                         no value given (multiqueue)    info
  FUA / write cache (sdd)          0 / write back               only with FUA=1 trace flag 3979 info

mssql.conf not readable or not present (defaults apply; in a container possibly MSSQL_* variables).
Linux default: forced flush (trace flag 3982), control.writethrough = 1, control.alternatewritethrough = 1.
Never set writethrough = 0 unless it is proven that the storage is O_DIRECT safe.

/* PSG Stack · SQL Server on Linux and Docker · Query 4 "Operations check"   Checks settings and waits that matter on Linux for performance and stable operation:   flush trace flags, memory limits and memory pressure, CPUs and schedulers, MAXDOP, tempdb,   waits when writing the transaction log. One row per check with a rating.    !!! WARNING — please read before running !!!   - Read-only. The query changes no data and no setting.   - Permissions: VIEW SERVER STATE (from 2022, VIEW SERVER PERFORMANCE STATE covers most checks);     without VIEW ANY DEFINITION the tempdb check reports "not checked".   - MAXDOP 1: every part runs serially and uses no additional cores.   - Waits count since the last start or since the statistics were last cleared.   - Rating "check" means: look closer, do not change automatically. Guidelines follow Microsoft     Learn (Linux performance pages, as of 05/2026) and the PSG lab; they do not replace an analysis.   - SQL Server 2017 and later. Tested in the PSG lab on 2017, 2019, 2022 and 2025 in Linux containers,     as sa and without sysadmin (13 Nov 2026); not tested on Windows (Linux checks show n/a there).*/SET NOCOUNT ON; DECLARE @r TABLE (nr int, area nvarchar(20), [check] nvarchar(80), value nvarchar(200),                  guideline nvarchar(200), rating nvarchar(10), note nvarchar(400));DECLARE @linux bit = 0, @cpu int, @sched int, @mem_mb bigint, @target_mb bigint, @model nvarchar(60),        @maxmem bigint, @maxdop int, @ctp int, @container nvarchar(60) = N'n/a'; IF OBJECT_ID(N'sys.dm_os_host_info') IS NOT NULL    SELECT @linux = CASE WHEN host_platform = N'Linux' THEN 1 ELSE 0 END FROM sys.dm_os_host_info OPTION (MAXDOP 1); SELECT @cpu = cpu_count, @mem_mb = physical_memory_kb / 1024, @target_mb = committed_target_kb / 1024,       @model = sql_memory_model_descFROM sys.dm_os_sys_info OPTION (MAXDOP 1);IF EXISTS (SELECT 1 FROM sys.all_columns WHERE object_id = OBJECT_ID(N'sys.dm_os_sys_info') AND name = N'container_type_desc')    EXEC sys.sp_executesql N'SELECT @c = container_type_desc FROM sys.dm_os_sys_info OPTION (MAXDOP 1);', N'@c nvarchar(60) OUTPUT', @c = @container OUTPUT;SELECT @sched = COUNT(*) FROM sys.dm_os_schedulers WHERE status = N'VISIBLE ONLINE' OPTION (MAXDOP 1);SELECT @maxmem = CONVERT(bigint, value_in_use) FROM sys.configurations WHERE name = N'max server memory (MB)' OPTION (MAXDOP 1);SELECT @maxdop = CONVERT(int, value_in_use) FROM sys.configurations WHERE name = N'max degree of parallelism' OPTION (MAXDOP 1);SELECT @ctp = CONVERT(int, value_in_use) FROM sys.configurations WHERE name = N'cost threshold for parallelism' OPTION (MAXDOP 1); /* 1 · Writing and flushing (Linux only) */DECLARE @tf TABLE (TraceFlag int, Status int, Global int, Session int);BEGIN TRY    INSERT @tf EXEC (N'DBCC TRACESTATUS(3979, 3982, 8002, -1) WITH NO_INFOMSGS');END TRYBEGIN CATCHEND CATCH;INSERT @r SELECT 1, N'Flush', N'Flush mode (trace flag 3979)',    CASE WHEN @linux = 0 THEN N'n/a (Windows)' WHEN NOT EXISTS (SELECT 1 FROM @tf) THEN N'not readable'         WHEN EXISTS (SELECT 1 FROM @tf WHERE TraceFlag = 3979 AND Global = 1) THEN N'FUA writes (3979 on)'         ELSE N'forced flush (default, 3979 off)' END,    N'forced flush, unless the storage provably supports FUA', N'info',    N'Forced flush is the Linux default, even though DBCC TRACESTATUS does not show 3982 as active (PSG lab). 3979 only with FUA-capable storage and alternatewritethrough = 0.';INSERT @r SELECT 2, N'Flush', N'writethrough / alternatewritethrough', N'in mssql.conf (SQL Server does not show them)',    N'1 / 1 (default) or 1 / 0 with trace flag 3979', N'info',    N'Check with cat /var/opt/mssql/mssql.conf, section [control]; if it is missing, the defaults apply. writethrough = 0 can lose data.'; /* 2 · Waits when writing (since start) */DECLARE @total bigint, @flush bigint, @wl_ms bigint, @wl_n bigint;SELECT @total = SUM(wait_time_ms) FROM sys.dm_os_wait_statsWHERE wait_type NOT LIKE N'SLEEP%' AND wait_type NOT LIKE N'BROKER%' AND wait_type NOT LIKE N'XE%'  AND wait_type NOT LIKE N'%QUEUE%' AND wait_type NOT LIKE N'HADR%' AND wait_type NOT LIKE N'SQLTRACE%'  AND wait_type NOT LIKE N'CLR%' AND wait_type NOT LIKE N'FT_%' AND wait_type NOT LIKE N'%IDLE%'  AND wait_type NOT IN (N'WAITFOR', N'CHECKPOINT_QUEUE', N'DIRTY_PAGE_POLL', N'DISPATCHER_QUEUE_SEMAPHORE',      N'LOGMGR_QUEUE', N'REQUEST_FOR_DEADLOCK_SEARCH', N'SP_SERVER_DIAGNOSTICS_SLEEP', N'QDS_ASYNC_QUEUE',      N'QDS_PERSIST_TASK_MAIN_LOOP_SLEEP', N'QDS_CLEANUP_STALE_QUERIES_TASK_MAIN_LOOP_SLEEP', N'PWAIT_EXTENSIBILITY_CLEANUP_TASK',      N'SOS_WORK_DISPATCHER', N'PVS_PREALLOCATE', N'PREEMPTIVE_XE_DISPATCHER', N'PREEMPTIVE_OS_FLUSHFILEBUFFERS_IDLE')OPTION (MAXDOP 1);SELECT @flush = SUM(CASE WHEN wait_type = N'PREEMPTIVE_OS_FLUSHFILEBUFFERS' THEN wait_time_ms ELSE 0 END),       @wl_ms = SUM(CASE WHEN wait_type = N'WRITELOG' THEN wait_time_ms ELSE 0 END),       @wl_n  = SUM(CASE WHEN wait_type = N'WRITELOG' THEN waiting_tasks_count ELSE 0 END)FROM sys.dm_os_wait_stats OPTION (MAXDOP 1);INSERT @r SELECT 3, N'Flush', N'Share of PREEMPTIVE_OS_FLUSHFILEBUFFERS in waits',    CASE WHEN ISNULL(@total, 0) = 0 THEN N'no waits'         ELSE CONVERT(nvarchar(20), CONVERT(decimal(5, 1), 100.0 * @flush / @total)) + N' %' END,    N'often near the top on Linux, not a finding on its own', N'info',    N'Corresponds to the fdatasync call SQL Server makes on Linux (Paul Randal, Bob Dorr). Only an issue together with high WRITELOG times.';INSERT @r SELECT 4, N'Flush', N'WRITELOG, average wait per commit wait',    CASE WHEN ISNULL(@wl_n, 0) = 0 THEN N'none' ELSE CONVERT(nvarchar(20), CONVERT(decimal(9, 2), 1.0 * @wl_ms / @wl_n)) + N' ms' END,    N'a few milliseconds', CASE WHEN @wl_n > 0 AND 1.0 * @wl_ms / @wl_n > 5 THEN N'check' ELSE N'ok' END,    N'High values: slow log storage, log in the container writable layer (overlayfs) or very many small transactions.'; /* 3 · Memory */INSERT @r SELECT 5, N'Memory', N'max server memory vs. visible memory',    CONVERT(nvarchar(20), @maxmem) + N' MB of ' + CONVERT(nvarchar(20), @mem_mb) + N' MB',    N'set, below visible memory, with headroom',    CASE WHEN @maxmem >= 2147483647 OR @maxmem > @mem_mb THEN N'check' ELSE N'ok' END,    N'On Linux, memory.memorylimitmb (or MSSQL_MEMORY_LIMIT_MB) limits the whole process, max server memory only the buffer pool. In a container, leave 10–20 % headroom to the container limit.';INSERT @r SELECT 6, N'Memory', N'Memory target (committed_target)',    CONVERT(nvarchar(20), @target_mb) + N' MB', N'below the container or host limit', N'info',    N'2017 and 2019 do not see the cgroup v2 limit of a container and plan with host memory (PSG lab, part 3).';INSERT @r SELECT 7, N'Memory', N'Memory model', @model, N'CONVENTIONAL is normal on Linux', N'info',    N'There is no documented equivalent of "Lock Pages in Memory" on Linux.';DECLARE @low int, @proc int;SELECT @low = CONVERT(int, system_low_memory_signal_state) FROM sys.dm_os_sys_memory OPTION (MAXDOP 1);SELECT @proc = CONVERT(int, process_physical_memory_low) FROM sys.dm_os_process_memory OPTION (MAXDOP 1);INSERT @r SELECT 8, N'Memory', N'Memory pressure now (system / process)',    CONVERT(nvarchar(5), @low) + N' / ' + CONVERT(nvarchar(5), @proc), N'0 / 0',    CASE WHEN @low = 1 OR @proc = 1 THEN N'check' ELSE N'ok' END,    N'1 means: SQL Server currently reports too little memory. If it stays 1, check limits and memory-hungry queries.'; /* 4 · CPU, schedulers, parallelism */INSERT @r SELECT 9, N'CPU', N'CPUs and visible schedulers',    CONVERT(nvarchar(10), @cpu) + N' CPUs, ' + CONVERT(nvarchar(10), @sched) + N' schedulers'      + CASE WHEN @container <> N'n/a' AND @container <> N'NONE' THEN N' · ' + @container ELSE N'' END,    N'as many schedulers as CPUs are actually available', N'info',    N'SQL Server does not see a CPU quota (docker --cpus). Remedy according to Microsoft: PROCESS AFFINITY and, under cgroup v2, trace flag 8002.';INSERT @r SELECT 10, N'CPU', N'Trace flag 8002 (soft processor affinity)',    CASE WHEN @linux = 0 THEN N'n/a (Windows)' WHEN NOT EXISTS (SELECT 1 FROM @tf) THEN N'not readable'         WHEN EXISTS (SELECT 1 FROM @tf WHERE TraceFlag = 8002 AND Global = 1) THEN N'on' ELSE N'off' END,    N'Microsoft: with PROCESS AFFINITY under cgroup v2; measure first', N'info',    N'Without 8002, PROCESS AFFINITY binds the schedulers firmly to individual CPUs. In the PSG lab (2019–2025, quota of 4 CPUs) 8002 added no measurable gain over affinity alone.';INSERT @r SELECT 11, N'CPU', N'max degree of parallelism', CONVERT(nvarchar(10), @maxdop),    N'at most 8 per NUMA node, not 0 with more than 8 schedulers',    CASE WHEN @maxdop = 0 AND @sched > 8 THEN N'check' ELSE N'ok' END,    N'MAXDOP 0 uses as many threads as schedulers are visible, even if the container gets less CPU.';INSERT @r SELECT 12, N'CPU', N'cost threshold for parallelism', CONVERT(nvarchar(10), @ctp),    N'not the default of 5', CASE WHEN @ctp = 5 THEN N'check' ELSE N'ok' END,    N'The default of 5 lets even very small queries run in parallel.'; /* 5 · tempdb */IF HAS_PERMS_BY_NAME(NULL, NULL, N'VIEW ANY DEFINITION') = 1BEGIN    DECLARE @n int, @equal bit, @percent int;    SELECT @n = COUNT(*), @equal = CASE WHEN MIN(size) = MAX(size) AND MIN(growth) = MAX(growth) THEN 1 ELSE 0 END,           @percent = MAX(CONVERT(int, is_percent_growth))    FROM sys.master_files WHERE database_id = 2 AND type = 0 OPTION (MAXDOP 1);    INSERT @r SELECT 13, N'tempdb', N'Data files',        CONVERT(nvarchar(10), @n) + N' files, ' + CASE WHEN @equal = 1 THEN N'same size' ELSE N'different sizes' END          + CASE WHEN @percent = 1 THEN N', percent growth' ELSE N'' END,        N'as many as schedulers, at most 8, same size, fixed growth',        CASE WHEN @n < CASE WHEN @sched > 8 THEN 8 ELSE @sched END OR @equal = 0 OR @percent = 1 THEN N'check' ELSE N'ok' END,        N'From 2019 a Linux installation creates up to eight files (Microsoft); the container images create one per CPU on first start, up to eight (PSG lab; 2017: one). Not on an in-place upgrade.';ENDELSE    INSERT @r SELECT 13, N'tempdb', N'Data files', N'not checked', N'', N'info', N'VIEW ANY DEFINITION is missing (sys.master_files).'; SELECT nr, area, [check], value, guideline, rating, note FROM @r ORDER BY nr OPTION (MAXDOP 1);

nr|area|check|value|guideline|rating|note
--|----|-----|-----|---------|------|----
1|Flush|Flush mode (trace flag 3979)|forced flush (default, 3979 off)|forced flush, unless the storage provably supports FUA|info|Forced flush is the Linux default, even though DBCC TRACESTATUS does not show 3982 as active (PSG lab). 3979 only with FUA-capable storage and alternatewritethrough = 0.
2|Flush|writethrough / alternatewritethrough|in mssql.conf (SQL Server does not show them)|1 / 1 (default) or 1 / 0 with trace flag 3979|info|Check with cat /var/opt/mssql/mssql.conf, section [control]; if it is missing, the defaults apply. writethrough = 0 can lose data.
3|Flush|Share of PREEMPTIVE_OS_FLUSHFILEBUFFERS in waits|22.5 %|often near the top on Linux, not a finding on its own|info|Corresponds to the fdatasync call SQL Server makes on Linux (Paul Randal, Bob Dorr). Only an issue together with high WRITELOG times.
4|Flush|WRITELOG, average wait per commit wait|0.56 ms|a few milliseconds|ok|High values: slow log storage, log in the container writable layer (overlayfs) or very many small transactions.
5|Memory|max server memory vs. visible memory|2147483647 MB of 4916 MB|set, below visible memory, with headroom|check|On Linux, memory.memorylimitmb (or MSSQL_MEMORY_LIMIT_MB) limits the whole process, max server memory only the buffer pool. In a container, leave 10–20 % headroom to the container limit.
6|Memory|Memory target (committed_target)|4267 MB|below the container or host limit|info|2017 and 2019 do not see the cgroup v2 limit of a container and plan with host memory (PSG lab, part 3).
7|Memory|Memory model|CONVENTIONAL|CONVENTIONAL is normal on Linux|info|There is no documented equivalent of "Lock Pages in Memory" on Linux.
8|Memory|Memory pressure now (system / process)|0 / 0|0 / 0|ok|1 means: SQL Server currently reports too little memory. If it stays 1, check limits and memory-hungry queries.
9|CPU|CPUs and visible schedulers|6 CPUs, 6 schedulers · LINUX CONTAINER|as many schedulers as CPUs are actually available|info|SQL Server does not see a CPU quota (docker --cpus). Remedy according to Microsoft: PROCESS AFFINITY and, under cgroup v2, trace flag 8002.
10|CPU|Trace flag 8002 (soft processor affinity)|off|Microsoft: with PROCESS AFFINITY under cgroup v2; measure first|info|Without 8002, PROCESS AFFINITY binds the schedulers firmly to individual CPUs. In the PSG lab (2019–2025, quota of 4 CPUs) 8002 added no measurable gain over affinity alone.
11|CPU|max degree of parallelism|0|at most 8 per NUMA node, not 0 with more than 8 schedulers|ok|MAXDOP 0 uses as many threads as schedulers are visible, even if the container gets less CPU.
12|CPU|cost threshold for parallelism|5|not the default of 5|check|The default of 5 lets even very small queries run in parallel.
13|tempdb|Data files|6 files, same size|as many as schedulers, at most 8, same size, fixed growth|ok|From 2019 a Linux installation creates up to eight files (Microsoft); the container images create one per CPU on first start, up to eight (PSG lab; 2017: one). Not on an in-place upgrade.