We have shown that, for columnar data, sorting by one column at
a time is much more efficient than sorting by all columns
at once. This efficiency can be attributed to a better cache
performance and fewer branches in the tuple comparison
function. However, we have found that sorting data in a row
format is almost always better than sorting columnar data,
mostly due to an even better cache performance.

Sorting is inherently a row-wise operation, but systems
with a vectorized engine use a columnar data format. For
such systems, it might be beneficial to convert the data to
a row format, also called the N-ary Storage Model (NSM),
and then convert it back to a columnar format, also called
the Decomposition Storage Model (DSM), after completing
the sort. Vectorized engines already do this for hash tables in
joins and aggregations [19].

From the results, it is clear that
sorting the row data format is more efficient than sorting the
columnar data format, as the relative runtime of the row sorting
approaches is greater than 1 for almost all inputs. For smaller
input sizes, sorting rows has a similar performance because
the data fits in the CPU’s cache. Therefore, the random access
incurred by the columnar approach does not affect the runtime
by much.
For larger input sizes, the data does not fit in the
CPU’s cache, and the improved cache locality of the row data
format results in a better performance.
In summary, NSM tuple representation performs much
better when sorting relational data than DSM. This is true
regardless of data distribution, and the performance gain is
especially noticeable when sorting a large number of tuples.
It remains to be seen whether converting to rows, sorting, then
converting back to columns is worth it in a system that uses the
DSM tuple representation in its query execution engine

The article observed that rapid fluctuations
between compute-intensive and memory-intensive
phases of AI workloads created voltage transients
that exceeded design tolerances. Particularly
concerning were failures during model checkpoint
operations, where synchronized memory writes
across multiple GPUs created power demand
spikes that voltage regulators struggled to
accommodate.

The article conducted a detailed analysis of a
production cluster comprising 2,048 GPUs
(NVIDIA A100 80GB) dedicated to large
language model training. Over six months, this
cluster experienced 137 distinct GPU failures
requiring replacement and 412 recoverable
incidents. The primary failure modes were thermal
degradation (41%) and memory subsystem issues
(28%). Notably, failure rates showed significant
positional dependence within racks, with GPUs in
the upper third of racks failing 2.3x more
frequently than those in the lower third. After
implementing enhanced cooling and predictive
maintenance, unplanned downtime decreased by
68%, and training completion time variability
decreased by 47%

The projection models indicate that without
significant architectural changes or cooling
innovations, large-scale AI training clusters may
see reliability decrease by 15-20% per GPU
generation while maintenance costs increase by 25-30%.