# Artificial neural networks for online error detection

Vassilis Vassiliadis<EMAIL_ADDRESS>Konstantinos Parasyris<EMAIL_ADDRESS>Christos D. Antonopoulos<EMAIL_ADDRESS>Spyros Lalis<EMAIL_ADDRESS>Nikolaos
Bellas<EMAIL_ADDRESS>Centre for Research and Technology Hellas
Volos, Greece  Department of Electrical and Computer Engineering
University of Thessaly
Volos, Greece

###### Abstract

Hardware reliability is adversely affected by the downscaling of semiconductor
devices and the scale-out of systems necessitated by modern applications.
Apart from crashes, this unreliability often manifests as silent data
corruptions (SDCs), affecting application output. Therefore, we need low-cost
and low-human-effort solutions to reduce the incidence rate and the effects of
SDCs on the quality of application outputs. We propose Artificial Neural
Networks (ANNs) as an effective mechanism for online error detection. We train
ANNs using software fault injection. We find that the average overhead of our
approach, followed by a costly error correction by re-execution, is $6.45\%$
in terms of CPU cycles. We also report that ANNs discover $94.85\%$ of faults
thereby resulting in minimal output quality degradation. To validate our
approach we overclock ARM Cortex A53 CPUs, execute benchmarks on them and
record the program outputs. ANNs prove to be an efficient error detection
mechanism, better than a state of the art approximate error detection
mechanism (Topaz), both in terms of performance ($12.81\%$ CPU overhead) and
quality of application output ($94.11\%$ detection coverage).

###### Index Terms:

unreliable computing, significance aware computing, artificial neural networks

##  I Introduction

The ongoing down-scaling of transistors as well as the reduced operating
voltages combined with scaling-out systems led to a dramatic rise in
susceptibility of processors [8, 23] and systems [40, 3] to faults. As
computing systems are now ubiquitous, a system malfunction is likely to have
more severe financial and social impacts than ever before. In one incident, a
single soft error crashed a system farm, while in another case a single soft
error disrupted the operation of a billion dollar automotive factory [44].
Several other incidents have been reported [30, 32]. Crashes are the obvious
side effects of hardware faults. Silent Data Corruptions (SDCs) may be even
more dangerous because they are not immediately observable. Unfortunately,
SDCs are also expected to appear more frequently [9].

Increasing the resilience of computing systems has become a primary concern.
Hardware architects have introduced several error protection mechanisms and
guardbands. However, those methods are not sufficient [31]. For example,
conventional circuit design techniques for high performance tune all timing
paths to the critical path. Consequently, when a single path fails more are
prone to failure, thereby negatively affecting the overall reliability of the
hardware [35, 39]. Moreover, improving the reliability of computations by
guardbanding and redundancy not only increases the cost of the manufacturing
process, but also constraints the performance of the designs, because they are
pessimistically configured for the worst-case scenario (critical path).

A major challenge is detecting quality-degrading errors before they
irreversibly modify application state. Ideally, a detection mechanism should
be able to distinguish between correct and incorrect computation results, at a
very low performance overhead. Fortunately, lower levels of the system such as
circuit, micro-architecture and architecture largely mask hardware faults
before they incur changes to the application layer [42]. Out of those which
manifest to the application state, it is important to detect the ones which
significantly affect the output quality of the application, and correct them
before they propagate to the output. Depending on application characteristics,
minor deviations from correct intermediate results may not be worth paying the
correction cost. There is a large body of work on approximate computing that
gracefully trades-off computation accuracy for improved performance, energy-
and power-efficiency [2, 29, 37, 41, 38, 22, 28, 13].

We introduce a methodology for automatic error detection, based on Artificial
Neural Networks (ANNs). ANNs have been successfully deployed in pattern
matching and classification applications, sometimes even outperforming human
accuracy [18, 4]. Typically, ANNs are treated as black boxes which, given
enough observational data, can become very efficient at classifying data and
approximating functions. Given the configurability of their architecture, one
can flexibly trade-off performance and classification accuracy by modifying
the number of layers and the number of nodes per layer.

This paper contributes the following:  (i) We use ANNs to detect hardware
errors during program execution. Furthermore, we compare our approach with
Topaz, a state of the art approximate error detection mechanism [2].  (ii) We
evaluate the overhead of our approach and its impact on the quality/accuracy
of the end result, on a set of $6$ applications from the domains of imaging,
finance and physics, via software fault injection experiments. We expand our
case-study to simulate the use of overclocked and unreliable CPU cores as a
means to optimize the performance of applications.  (iii) We present a case
study on ANN-based error-detection for $4$ applications that execute under
real unreliable conditions on an ARM Cortex A53 CPU.

We explore both software fault injection as well as real hardware that
operates under unreliable conditions. On the one hand, real hardware,
configured to operate outside its normal working envelope, leads to the
manifestation of real errors. Unfortunately, this requires support from all
levels of the system stack, from the application level all the way down to the
hardware level. Additionally, errors seldomly appear and thus it is difficult
to investigate the use of error detectors. As such, it is difficult to study
the behaviour of long running applications on real unreliable hardware.
Therefore, we first investigate the efficacy of our method for large input
data sets under simulated unreliable conditions. Then, we evaluate the use of
the very same error-detectors for applications which execute using real
unreliably configured hardware but with smaller input data sets.

We show that ANNs can act as efficient error detectors, offering a good trade-
off between accuracy and execution overhead. Also, our ANN generation method
is semi-automatic and requires minimum human effort.

The rest of the paper is structured as follows. Section II introduces the
conceptual model for the computations we target in this work. Section III
details our approach to automatic error detection using ANNs. Section IV
describes modeling of unreliable execution and Section V introduces an error
detector fitness metric. In Section VI we evaluate our methodology. Section
VII provides an overview of related work. Finally, Section VIII concludes the
paper.

##  II Conceptual model

For the purpose of this work we assume a task-based programming model, where
the computation is broken down to smaller tasks. The inputs and outputs of
each task are explicitly defined. Tasks can be executed in parallel, subject
to their data dependencies.

Some tasks are executed on potentially unreliable hardware. Consequently, a
task may experience an unexpected runtime error and crash, enter an endless
loop, or manage to complete but produce incorrect output. The first two types
of failures can be detected by the runtime system through the standard
operating system mechanisms and watchdog timers, respectively. On the
contrary, the last type of failure, also referred to as a silent data
corruption (SDC), is typically detected via error-detection code or some form
of voting mechanism such as Triple Redundancy Modular check (TRM) [27]. The
former uses code (typically supplied by the application programmer) that
inspects the output of the task to infer whether it is correct or not. The
latter involves multiple executions of the same task on different execution
vehicles and subsequent comparison of the respective results. Implementing
result checking can become tedious, whereas TRM may introduce extreme
overheads.

We assume that an error detector executes on reliable hardware and never
experiences SDCs. However, the error detector is not guaranteed to always make
correct decisions. This affects both the result quality/accuracy and the
execution time of applications. On the one hand, if an incorrect task output
is accepted as correct, it may eventually corrupt the global state of the
application, which will degrade, potentially significantly, the
quality/accuracy of the end result. On the other hand, correct output may be
classified as incorrect. This will unnecessarily trigger the correction/repair
mechanism, increasing the application execution time of the application. If
correction is performed via approximation unnecessary corrections may even
degrade the output quality.

Designing and implementing a fully accurate (perfect) error detector is too
costly to be practical in the general case, or even impossible for tasks that
perform non-deterministic computations. Employing a perfect error detector may
also be an overly conservative (and expensive) choice for computations that do
not need to produce fully accurate results. In this case, even inaccurate
error detectors can lead to acceptable results without penalizing performance.
This is where the usage of ANNs is particularly promising. Our goal is to
exploit the observation that most computations will finish successfully
without any observable error [34] and try to detect and correct the most
quality-degrading errors. This is the reason why we opt not to approximate
code.

Error correction is not the focus of this paper. For simplicity, we assume
that task outputs are not propagated/committed to the global state of the
program before error checking completes. Also if the output of a task is
considered to be incorrect then its output is ignored, and the task is re-
executed in a reliable configuration. While this incurs a high error recovery
cost, it can be acceptable as long as the error detector is successful in
detecting only those errors that would have a big impact on the end result of
the computation. An alternative error-correction approach is to employ an
approximate version of the task code in order to reduce the execution cost at
the price of producing inaccurate task output [41, 28, 13]. Since this would
also degrade the end quality/accuracy of the entire computation, it would be
harder to evaluate the impact of the error detection mechanism, which is the
focus of this paper. Therefore, in the context of this work we correct errors
through accurate and reliable task re-execution.

##  III Artificial neural networks for automatic error detection

Figure 1: Stages of proposed automatic error detection methodology.

The manual implementation of accurate and low cost error detection is a time
consuming and intricate process. The developer should be highly familiar with
the application in order to be able to take educated decisions on how to
detect errors in the output of each task. Also, it can be quite hard to find
the desired balance between execution complexity/cost and error detection
accuracy.

Previous work has mainly explored the use of manually implemented, low-cost,
but potentially approximate error-detectors [2, 17, 20, 16], and methods which
try to detect all possible SDCs, even if they do not necessarily affect the
application output quality [14, 26, 12, 24]. In contrast, we propose to use
ANNs as inaccurate error detectors. ANNs require little manual intervention,
offer the opportunity to trade-off error detection accuracy with performance
overhead in a flexible way and are widely used for classification purposes.

Typically, solving a problem through the use of ANNs involves training
multiple ones and selecting the fittest. Our methodology is illustrated in
Figure 1, it consists of four main steps: a) gathering data for the training
process, b) deciding the architecture of the ANNs, c) training the ANNs, and
finally d) deploying the ANNs. This section describes this process, for
constructing ANNs that will be used as error-detectors.

###  III-A Collecting training data

We begin by partitioning the application code into fine-grained tasks. The
outputs of those tasks are subject to error detection. The rationale is that
if the task size is rather small, then its output is more likely to exhibit a
detectable pattern. We train ANNs to identify this pattern (or deviations from
it).

The data which an ANN processes to determine whether the output of a task is
correct or incorrect is called as _feature vector_. The feature vector always
includes the task output. This can be sufficient for tasks with distinctive
output patterns, irrespective of their input. If the output pattern is highly
input-sensitive, the feature vector also has to include parts of the task
input, or in the extreme case the entire input. In the latter case the ANN
estimates whether the provided task output is correct for the given the task
input. This is an easier problem than the problem of learning to approximate
the function which the original task performs because, in our case, the ANN
detector does not necessarily need to predict the exact output. In this work,
the application developer manually defines the feature vector, although in
principle this step could also be automated through some dimensionality
reduction method, for example principal component analysis.

The application is then executed reliably for different inputs. In every
execution, we record the feature vector of each task. This data is aggregated
for each task across all executions to produce a so-called _profile_ data set.
We select $\sim 90\%$ of the profile data set to construct the _training_ set,
while the remaining $\sim 10\%$ of the profile set is used as the _test_ set.
We update the weights of the ANNs using the _training_ set and perform early
stopping by monitoring the loss on the _test_ set (Section III-C).

###  III-B ANN structure

For online error detection, we consider the least complicated type of ANNs:
Multilayer Perceptrons that consist of InnerProduct (IP) layers. Rectified
Linear Units (ReLUs) serve as activation functions between IP layers.

IP layers accept $M$ inputs and produce $N$ outputs. Each such layer contains
an $MxN$ matrix of weights ($W$) and a vector ($\vec{b}$) that contains $N$
bias values. Assuming that the vector $\vec{x}$ is input to an IP layer, the
resulting output vector is $\vec{y}=W*\vec{x}+\vec{b}$. ReLU activation layers
are placed between two IP layers to introduce non-linearities which improve
the generalization of the ANN as well as classification performance. A ReLU
with an input vector $\vec{x}$ and output vector $\vec{y}$ computes
$y_{i}=max(0,x_{i})\;\forall\;x_{i}\in\vec{x}$.

Figure 2: Structural template for the generated ANNs. The input is the feature vector of the task. The output consists of two values corresponding to the one-hot classification of the task output as correct or incorrect.  Notation | Structure
---|---
N,2 | $f[N]\rightarrow IP[2]\rightarrow out[2]$
N,B/2,2 | $f[N]\rightarrow IP[B/2]\rightarrow ReLU\rightarrow IP[2]\rightarrow out[2]$
N,B,2 | $f[N]\rightarrow IP[B]\rightarrow ReLU\rightarrow IP[2]\rightarrow out[2]$
N,B*2,2 | $f[N]\rightarrow IP[B*2]\rightarrow ReLU\rightarrow IP[2]\rightarrow out[2]$
N,B/2,B/2,2 | $f[N]\rightarrow IP[B/2]\rightarrow ReLU\rightarrow IP[B/2]\rightarrow ReLU\rightarrow IP[2]\rightarrow out[2]$
N,B,B/2,2 | $f[N]\rightarrow IP[B]\rightarrow ReLU\rightarrow IP[B/2]\rightarrow ReLU\rightarrow IP[2]\rightarrow out[2]$
N,B*2,B/2,2 | $f[N]\rightarrow IP[B*2]\rightarrow ReLU\rightarrow IP[B/2]\rightarrow ReLU\rightarrow IP[2]\rightarrow out[2]$
TABLE I: The seven different ANNs used for error detection. $f$ is the feature
vector of the task, $N$ is the size of the feature vector, $B$ is the power of
2 closest to $N$, and $out$ is the 2-dimensional output. The dimension of the
input/output vectors and IP layers are given in brackets

For every task function for which we wish to build an error detector, we
experiment with various ANN structures, according to the template shown in
Figure 2. The input of the first IP layer is always the feature vector for the
task in question (the size of the vector depends on the task). The last IP
layer produces exactly two values, to encode the confidence of the ANN that a
task output is correct or not. Our ANNs are _one-hot classifiers_ where each
component of the output vector gives a score for the correctness and the
incorrectness of the input feature vector, respectively. The component with
the highest score is considered to be the output of the ANN classifier. In the
unlikely event of a tie, we assume that the output is incorrect. With each ANN
we explore a different combination for: (a) the number of IP layers and ReLUs,
and (b) for the sizes of these layers, for which we try out different powers
of 2 as this facilitates vectorization. These ANNs vary in their internal
computational complexity and may also have different error-detection accuracy.
More specifically, for each task we consider the 7 ANNs structures listed in
Table I. These ANN structures are produced automatically, based on the size of
the feature vector.

###  III-C Training the ANNs

We train the ANNs using Caffe [19]. Training is done in _epochs_ : an epoch is
over when the training set has been fed-forward, the loss function for the
resulting ANN outputs has been evaluated, and the weights have been adjusted
by back-propagation of the loss on the test data. The completion of the
training process is decided using the following heuristic. Initially, when
training starts, we issue 100 _tickets_. At the end of each epoch we check the
loss of the ANN on the _test_ data. If the test loss has decreased compared to
the previous epoch, then the number of tickets is increased by $1$ (to a
maximum of 100), else it is decreased by $2$. When there are no tickets left,
the ANN is assumed to have reached an acceptably low loss, and training
terminates. We reward the reduction of loss to assist the recovery from local
test-loss minima. After all, consecutive training epochs may increase the test
loss before it is eventually reduced beyond its past minimal value.

For a task output that comprises $N$ values, each one consisting of $k$-bits,
the possible different incorrect output variants are $N*(2^{k}-1)$. If during
training one considers all possible incorrect values for a single correct
output, this would bias the ANN to always infer that a feature vector is
incorrect, as that would minimize the loss function. One the one hand, it is
possible to counter-balance all the possible incorrect output patterns by
scaling the loss for the correct feature vectors. Unfortunately, taking into
account all possible errors would dramatically increase the size of the
training and test data sets and lead to unacceptably long training times.

As a more practical approach, we rely on data augmentation to periodically
generate data sets containing equal numbers of _correct_ and _incorrect_
feature vectors. We perturb the correct feature vectors (from the profile
data) to produce incorrect ones, every few training epochs. This way the ANNs
are trained to classify feature vectors that have a strong similarity (but are
not necessarily identical) to the correct ones as _correct_ , and to classify
widely different patterns as _incorrect_.

###  III-D Deployment

We have implemented a Caffe-to-C python script which takes an ANN model from
Caffe and produces C code that performs just the inference (feed-forward)
operation. The C code consists mostly of gcc vector extension intrinsics, and
we rely on gcc to automatically generate vectorized implementations for
maximum performance. In terms of operations, IP layers comprise floating point
additions, subtractions and multiplications. ReLUs can be implemented via the
gcc built-in function $fmaxf()$, or using binary arithmetic.

Finally, we add the code of the ANN-based error-detectors in the application.
These are invoked post task completion, to check their output and decide
whether they need to be re-executed. However, recall that tasks are
intentionally fine-grained, and it is unrealistic for the application to be
executed at such an extremely fine level of granularity. Due to the system-
level task management overheads, this would incur significant performance
penalty. To reduce this overhead, we group a large number of independent tasks
into large _gangs_ , which are the actual, and much coarser, scheduling unit
for the underlying runtime system. When a gang completes its execution, the
output of each task is checked individually via the corresponding ANN, and if
it is classified as incorrect then the task is flagged for re-execution.

We also explore _batched_ error-detection by checking for errors in the
aggregated outputs of several tasks. A task batch typically comprises just a
few tasks (which can have dependencies), and for all practical purposes it can
be treated as if it was a single, coarser task. The process for producing the
respective error detection ANNs remains similar to the one described above.
Application profiling and ANN training are exactly the same. The difference is
that the feature vector has to be defined to include the aggregated outputs of
the task batch and possibly parts of the aggregated inputs.

##  IV Modeling unreliable execution

We present 3 case studies: 2 fault injection campaigns on the Intel i7 4820k
CPU, and a set of unreliable execution experiments on the ARM cortex A53 CPU.

###  IV-A Software fault injection

To perform software-fault injection we use the methodology described in [34].
A fault-injection experiment injects random multiple-bit-flip faults on
architecturally visible registers once every $10^{7}$ cycles. For the software
fault injection campaigns we perform $192000$ experiments, for a confidence
level of $99\%$ and average margin of error $1.025\%$ for each of the $6$
benchmarks. The runtime system executes the main application thread under
reliable conditions and schedules tasks on 4 worker threads which are mapped
on the cores of the Intel i7 4820k CPU.

###  IV-B Real unreliable execution

For our third case study we use the ARM cortex A53 CPU of the Raspberry PI
model 3b which we configure to execute unreliably. During execution time the
CPU receives input for a gang-of-tasks, which it processes unreliably, and
finally it returns the task outputs to a master PC that records the inputs and
outputs of the tasks.

We use these outputs of true unreliable tasks but we perform error detection &
correction as well as performance measurements using the Intel i7 CPU. This
enables us to detect the presence of real errors while using a consistent
performance model. For each benchmark we collect $1000$ sets of task outputs
which contain more than 1 incorrect task output.

##  V Error detection fitness metric

To evaluate our error detection method we consider the efficiency of the
classifier to detect errors accurately as well as the overall overhead
introduced by error detection and correction. The performance overhead of the
ANN error detection mechanism depends on both its computational complexity and
its level of precision and recall. For every _incorrect_ task, the cost of
performing corrective action (task re-execution in our evaluation) is added on
top of the detection overhead itself.

Table II presents the metrics that we used to evaluate our framework. EEOP can
be used to choose the fittest out of a set of error detectors. The lower the
EEOP value the better the detector is.

Metrics |  Description
---|---
TPR: True Positive Rate |  The detector correctly considers the task output as incorrect. (The output is indeed incorrect)
FPR: False Positive Rate |  The detector falsely considers the task output as incorrect (the output is correct)
TNR: True Negative Rate |  The detector correctly considers the task output as correct
FNR: False Negative Rate |  The detector falsely considers the output as correct (The output is incorrect)
MRE: Missed Relative Error |  The average relative error across all FNR outputs.
EE: Expected Error |  Quantifies the average relative error of FNR classifications $EE=FNR*MRE=(1-TPR)*MRE$
Overhead: Error Detection and Correction Overhead |  The percentage of cycles spent to detect and correct errors with respect to the cycles required to execute a benchmark under reliable conditions.
EEOP: Expected Error/Overhead Product |  Combines the accuracy and the overhead of the detector $EEOP=EE*Overhead$
TABLE II: Metrics used to evaluate our methodology

Note that the EEOP metric, as defined in Table II, may produce acceptable
scores even for error-detectors that have very large overheads. Such overheads
might occur due to either the complexity of the error-checking mechanism or an
abnormally high False Positive Rate (FPR). We modify EEOP so that it discards
inefficient error-detectors using a user-supplied value ($\epsilon$)111In our
experiments, we set $\epsilon$ equal to $33\%$ that specifies the highest
tolerated error detection and correction Overhead:

$\small\textrm{\it EEOP{}}=\begin{cases}\textrm{\it Expected
Error}*Overhead,&Overhead\leq\epsilon\\\ \infty,&Overhead>\epsilon\end{cases}$
(1)

EEOP is a composite metric, that does not directly translate to a physical
property. Reasoning on individual metric scores is invalid. However, the
comparison of EEOP values for different error detectors enables automatic
systems to evaluate them using a single metric that combines both overhead and
error-detection related properties. This is particularly useful in our case,
because we automatically generate a number of ANN error detectors which
typically represent different trade-off points between output quality and
execution overhead. EEOP enables us to automatically select the fittest error
detector out of many, without requiring human intervention beyond specifying
the maximum overhead threshold ($\epsilon$).

##  VI Evaluation

In this section, we discuss the experimental evaluation of the ANN error
detection methodology and we compare our methodology against Topaz [2], both
in terms of accuracy and performance. Topaz executes computations using a
heterogeneous computing platform that comprises a reliable main worker thread
and multiple unreliable worker threads. It includes an approximate outlier
detector which checks for the existence of errors on Abstract Output Vectors
(AOVs). AOVs are constructed using either just the outputs of tasks or a
developer implemented function. The latter operates on both inputs and outputs
of a task to generate an AOV222In the case of ANNs, the equivalent of an AOV
is a feature vector which encodes the output vector of a task in a space of
lesser dimension. Unlike ANNs, Topaz does not require an offline phase. When
Topaz detects an error at the output of a task (false/true positive) it re-
executes the task reliably, updates its error detection model, and then
integrates the correct result in the main computation. The comparison between
our offline trained error detectors and the online training approach of Topaz
is particularly interesting. On the one hand, contrary to Topaz, our detectors
are capable of judging whether or not a task produced outputs from the very
first specimen that they encounter. On the other hand, Topaz requires a warm-
up phase but it may then theoretically adapt to accommodate for shifts in the
distribution on errors.

Given that detecting such shifts to the errors is not a trivial issue, Topaz
updates its error detection model via a heuristic. Essentially, it forgets
parts of its error detection model on a predetermined update cycle. In order
to perform a fair comparison we take into account the warm-up phase of Topaz
by executing large numbers of tasks for all of our benchmarks. Specifically,
the validation datasets in Sections VI-C and VI-D involve on average 5,886,250
tasks (with a median number of tasks equal to 1,846,252). In Section
LABEL:subsect:pi_analysis we use validation datasets of about 13,127 tasks
(with a median of 10,000 tasks). As such, in all three case studies we treat
Topaz fairly.

Both Topaz and ANNs can use more sophisticated AOVs/feature vectors which are
generated via programmer provided functions that operate on the inputs and
outputs of tasks. However, this increases the expected programmer effort.
Because the focus of this work is error detection without the involvement of
the programmer, we will not explore more intricate feature vectors beyond the
inputs and outputs of tasks. Furthermore, the authors of Topaz argue in favor
of reducing the number of AOV dimensions via batching before performing the
outlier detection test. We also apply batching by aggregating the
AOVs/Feature-Vectors of $N$ tasks into a single batch, before checking for
errors on an aggregate value produced by the outputs of tasks. If the
ANN/Topaz at the batch level detect an error, all $N$ tasks within the batch
are re-executed.

###  VI-A Benchmarks

Discrete Cosine Transformation (DCT) is used in image and video compression to
transform a block of 8x8 image pixels to a block of 8x8 frequency
coefficients. Low frequency coefficients are closer to the upper left corner
of the 8x8 block, whereas high frequency coefficients reside in the lower
right corner. A single task computes a 2x4 block of frequency coefficients. We
construct the training and testing data sets using a set of images from [1].
For the evaluation of both error detectors we use a third input set, the
validation data set, which differs from both the training and testing data
sets. For DCT, the validation data set contains images from the Image
Compression [5] data set. Each task feature vector contains the $8$ DCT
coefficients of the $2x4$ block as well as its offset within the $8x8$ block
of coefficients. All tasks but those which compute the DCT coefficients
residing in the upper left corner of the $8x8$ block are computed unreliably.
The upper left corner significantly affects the final output quality. As such,
it would be highly inefficient to subject the respective computations to
unreliable execution conditions [41]. A reliable execution of DCT (with
quantization) has an output PSNR of $35.6916$ dB.

Blackscholes is a benchmark from the PARSEC suite [6]. It implements a
mathematical model for a market of derivatives, which calculates the buying
and selling price of assets so as to reduce the financial risk. A task uses
the Black-Scholes mathematical model to produce the price of a single asset.
The training data set contains 400,000 assets and the testing-data set
contains 40,000 assets. The validation data set comprises 100,000 assets. The
three data sets are generated using a modified version of the PARSEC
Blackscholes input generator which produces permutations of its bundled 2000
asset entries. Each data set is constructed using different data-ranges, so
that the training/testing data and validation data are not the same. In
Blackscholes the feature vector consists of all $8$ inputs and output of the
task.

Bonds [15] is a computational finance benchmark of the QuantLib library. In
finance, a bond is an indication of indebtedness of the bond issuer to the
holders. The issuer is obligated to pay the holders a debt which increases by
a specified interest and/or pay the face amount at a pre-determined date
referred to as the maturity date. Interest payments are deposited in
intervals. Bonds includes a random bond generator used to generate 440,000
bonds for the training and testing data sets. The validation data set is
100,000 bond prices. Similarly to Blackscholes, we generate the input data
using different value ranges. The feature vector of a Bonds task comprises
both its inputs and outputs.

Lulesh [21] implements a solution of the Sedov blast problem for a material in
3 dimensions. It defines a discrete mesh that covers the region of interest
and partitions the problem into a collection of elements where hydrodynamic
equations are applied. A single task computes the hydrodynamic equations for 8
elements. The training data set profiles the execution of 4 different problem
sizes333In Lulesh, the problem size determines the number of elements involved
in the computation, e.g the problem size of 10 involves $10^{3}$ elements.
(N=5, 10, 15, and 20). The testing data set contains profile data for a
problem size equal to N=18. The validation input-data is a problem size of
N=50. Feature vectors for Lulesh contain the output of task, which is the
computed forces for $8$ bodies, along with the time-stamp of the step which is
a task input. All tasks are executed unreliably, apart from a random $10\%$
which are always executed reliably to improve numerical stability.

Inversek2j is a robotics benchmark from the AxBench suite [43]. Inversek2j
calculates the angles of a 2-joint arm using the kinematic equation. A task
computes the pair of angles for a single 2-joint arm. We generate 1.1 million
starting points to construct the training and testing data sets. For
Inversek2j we include the inputs and output of the task in the feature vector.

###  VI-B Case study: Real unreliable execution on ARM cortex A53

In our first case study we evaluate whether our methodology produces error
detectors which generalize to real errors originating from unreliable hardware
execution. To this end, we use the XM2 framework [33] which enables us to
execute code under unreliable conditions. Specifically, we increase the stock
CPU frequency of the ARM cortex A53 CPU which is present on Raspberry PI model
3b from 1.2GHz up to 1.4GHz to create the unreliable environment for our
experiments. We then execute the tasks of each benchmark multiple times, and
record the outputs of unreliable executions which differ from error-free
executions. We repeat this process to collect 1000 outputs that contain errors
for each different type of tasks for 4 benchmarks.

Table III presents the results of our experiments for batched error-detection
which intuitively presents itself as the worst case scenario in terms of error
classification accuracy. Recall that for batched error detection the feature
vector contains information for multiple tasks. We ask that the reader focuses
first on the results for DCT for which we show the metrics for all of the 7
ANNs plus Topaz. The majority of the ANNs feature a high TPR and low FPR. Our
detectors generalize to correctly detect the majority of real errors even
though we used software fault injection during training. The remaining
benchmarks have similar behaviour so in the interest of saving space we
present a subset of the 7 ANNs.

Interestingly, our experiments on real unreliable execution highlight the
importance of using EEOP. For example in the case of Blackscholes it would be
an understandable mistake to pick Topaz as the optimal error detector because
of its extremely low FPR and high TPR. However, it will become apparent in the
next following case study that Topaz actually induces a higher computational
overhead in comparison with the best ANN. Clearly, it is hard to deduce the
fittest error detector based on just output quality and error detection
metrics.

Benchmark | Detector | TPR ($\%$) | FPR ($\%$) | Quality (dB)
---|---|---|---|---
DCT | 10, 2 | 14.43 | 14.94 | 31.97
| 10, 4, 2 | 61.59 | 3.54 | 34.26
| 10, 4, 4, 2 | 61.72 | 1.3 | 34.60
| 10, 8, 2 | 85.95 | 3.19 | 36.56
| 10, 8, 4, 2 | 93.32 | 4.77 | 37.34
| 10, 16, 2 | 85.69 | 3.33 | 36.56
| 10, 16, 4, 2 | 92.53 | 2.62 | 35.99
| Topaz | 53.71 | 2.64 | 37.15
Benchmark | Detector | TPR ($\%$) | FPR ($\%$) | Rel. Error ($\%$)
Blackscholes | 8, 2 | 70.17 | 2.64 | 4.29
| 8, 2, 2 | 85.15 | 24.69 | 1.87
| 8, 8, 2, 2 | 88.25 | 25.29 | 1.27
| Topaz | 76.50 | 1.20 | 2.94
Bonds | 6, 4, 2 | 28.91 | 10.60 | 0.34
| 6, 8, 2 | 27.74 | 0.10 | 0.32
| 6, 16, 2 | 27.60 | 0.09 | 0.33
| Topaz | 73.36 | 4.42 | 0.12
Inversek2j | 4, 4, 2 | 50.41 | 0.04 | 0.14
| 4, 4, 4, 2 | 5.10 | 0.03 | 0.27
| 4, 8, 4, 2 | 55.26 | 0.04 | 0.12
| Topaz | 11.07 | 2.43 | 0.25
TABLE III: Accuracy metrics, and resulting output qualities for batched-error
detection. The baseline output quality for DCT is 38.05 dB, the remaining
benchmarks present the relative error between unreliable executions and an
error-free execution output as the baseline. Note that, True Positive Rate
(TPR) indicates error coverage, and False Positive Rate (FPR) the percentage
of correct tasks which were flagged for re-execution. Finally, numbers in bold
indicate the best in their category (per-benchmark)

###  VI-C Case study: Performance and quality evaluation

We use $6$ benchmarks from the domains of imaging, finance, and physics. For
all benchmarks but two (DCT and Sobel), the quality metric is the Relative
Error between the output of the unreliable execution and the error-free
execution. In DCT we measure the overall quality of the benchmark execution as
the Peak Signal to Noise Ratio (PSNR) between the input image and the image
that is the outcome of a sequence of DCT, quantization, de-quantization and
inverse-DCT operations. For Sobel, we measure the PSNR of the output of the
unreliable execution with respect to an error-free execution. For all
benchmarks, the error-free execution involves the scheduling of tasks on
hardware which is configured to operate reliably.

The remainder of this section presents, quality and performance metrics for
the ANN and the Topaz error detection methodologies for each benchmark.
Performance overhead is calculated as the percentage of CPU cycles required
for error detection and correction with respect to the cycles required to
execute the application reliably. Note that, both error detection and
correction are executed under reliable conditions.

Figure 3: DCT, Sobel Quality/Overhead

Figure 4: Lulesh, Blackscholes, Bonds, Inversek2j Quality/Overhead

Figure 5: DCT, Sobel Quality/Overhead (Batch)

Figure 6: Lulesh, Blackscholes, Bonds, Inversek2j Quality/Overhead (Batch) | Original | Batched
---|---|---
Benchmark | ANN | Topaz | ANN | Topaz
DCT | 0.04 | 0.14 | 0.032 | 0.033
Sobel | 3.63 | 3.82 | 1.26 | 1.87
Lulesh | 6.1e-5 | $\infty$ | 3.1e-5 | $\infty$
Blackscholes | 6.7e-4 | 1.7e-2 | 1.3e-3 | 9.0e-4
Bonds | 1.7e-3 | 2.0e-4 | 1.4e-3 | 1.5e-3
Inversek2j | 6.6e-6 | $\infty$ | 1.6e-3 | 5.2e-3
TABLE IV: EEOP values for all evaluated error-detectors. Lower numbers
indicate more efficient detectors. Bold numbers indicate the fittest error
detector. ANNs outperform Topaz in 5 and 4 out of 6 benchmarks when batching
is toggled off and on respectively.

Figures 4-6 present the Quality/Overhead measurements for both batch-enabled
and non-batched versions of the $6$ benchmarks. For each benchmark we
illustrate the results obtained using Topaz as well as the best performing ANN
based on EEOP. Table IV summarizes the EEOP values. On average, the per-
benchmark fittest ANNs delivered an average _Detection Coverage_ of $94.85\%$
whereas Topaz scored marginally worse at $94.11\%$. Interestingly, the ANNs
induce a much lower overhead in comparison to Topaz. In fact without the use
of batched error-detection Topaz results in extreme overheads in 3 out of 6
benchmarks.

Both ANNs and Topaz are most efficient for applications with tasks that handle
few data but execute for a long time. One example of such an application is
Bonds. Tasks that perform few computations for large sets of data (i.e. Sobel)
behave poorly with this type of error detection. Large feature vectors lead to
an increased overhead for error detection.

Especially for multimedia applications we expect that there are better
alternatives to Multilayer Perceptrons like Convolutional Neural Networks
(CNNs) [25]. CNNs have been designed to exploit the spatial information of
data contained within a feature vector. This information is implicitly defined
by the indices of the data within the vector.

###  VI-D Case study: An unreliable configuration at the PoFF

The Point Of First Failure (PoFF) [11] denotes a point at which errors
manifest at a frequency of one error every $10^{7}$ cycles. Hardware
configurations which are closer to nominal values still exhibit errors,
however at exponentially lower rates. Hardware operates at its PoFF when its
voltage supply is approximately $85\%$ of the nominal value for the current
frequency setting[7]. Every additional $10mV$ drop in voltage supply increases
the fault rate exponentially by one order of magnitude[11].

Figure 7: Fault rate, measured as a function of $\frac{1}{cycles}$, and CPU
voltage for a specific CPU frequency

Figure 7 shows the fault rate as a function of the supply voltage, when the
clock frequency remains constant. There is a region ($\delta$) near $V_{PoFF}$
in which unreliable computing is the most efficient for improvements in
performance, power, and/or energy [34]. Moving closer to $V_{nominal}$ leads
to less frequent faults at the cost of reduced performance/energy/power gains.
But, the error detection overhead remains the same because all unreliably
executed tasks need to be checked for errors, regardless of how likely it is
for them to have to produced faulty results. Conversely, extreme sub-nominal
voltage/frequency configurations, outside the nominal operating envelope, lead
to higher fault rates and increase the correction overhead thereby outweighing
any performance/energy/power benefits.

A CPU operates nominally (i.e. error free) on a (V, f) line. The CPU may
dynamically move to multiple configurations between a lower and a higher
performance point under the control of the Operating System (OS). For example,
when the workload is low or memory-bound, the OS can switch the CPU core(s)
closer to the lower performance point to save power. In this section, we
evaluate whether we can reliably operate the CPU under unreliable
configuration to reduce execution time using the proposed error detection
technique.

For our experiments on the Intel i7 4820k CPU, we use two configurations. The
first configuration is reliable ($V_{nominal}$, $f_{nominal}$) = ($0.9$ V,
$1.67$ GHz). The second one is unreliable ($V_{nominal}$, $f_{overclocked}$) =
($0.9$ V, $3.7$ GHz). The unreliable configuration corresponds to the PoFF
(note that $0.9\approx 0.85*1.06$) and falls well into the unreliable area
(Figure 7) due to overclocking. Overclocking provides lower execution time
under unreliable conditions, which may result in crashes or SDCs. Error
detection and correction mechanisms are then deployed to alleviate the effects
of unreliable configurations, at the expense of performance (discussed in
Section VI-C). It is this interplay between output quality and performance
(faster clock vs. correction/detection overhead) that we evaluate in this
subsection.

We selected these specific (V, f) points to illustrate the performance gains
of our methodology mainly because switching between them only requires a fast
clock scaling [10], rather than a slow voltage scaling mechanism. However,
this analysis is applicable to any pair of reliable and unreliable operational
points, including undervolting. For our experiments which involve large input
data sets we use the software fault injection methodology of Section IV-A and
inject faults at a rate of $1$ fault every $10^{7}$ cycles. To obtain an upper
bound of the speedup, we introduce an oracle-like error detection mechanism
with perfect _Detection Coverage_ (TPR=1, FNR=0) and zero detection overhead.
The oracle mechanism still pays the overhead of error correction by task re-
execution.

Table V compares the fittest ANNs and Topaz against the Oracle for each
benchmark. The speedup baselines are error-free executions of the applications
using the fully reliable voltage/frequency configuration of ($V_{nominal}$,
$f_{nominal}$). Keep in mind that for our applications we execute all tasks,
unless otherwise specified, on unreliable cores which operate under the
($V_{nominal}$, $f_{overclocked}$) configuration. The remaining parts of the
applications are executed under reliably ($V_{nominal}$, $f_{nominal}$). The
average speedup of the theoretical Oracle error detector is $1.99$x, the
resulting output is by definition bit-wise exact since the Oracle always
detects an _Incorrect_ task output. Even though both ANNs and Topaz exhibit
similar behavior in terms of _Detection Coverage_ , the ANNs exhibit higher
speed up at $1.51$ vs. $1.15$ for Topaz. The difference is mainly due to the
higher error-detection overhead in Topaz (which is true also in the batched
version of the benchmarks). The best scoring ANNs in batched configuration, on
average, achieve an execution speedup of $1.72x$ which is larger than Topaz’s
$1.44$x. Again, the difference is mainly due to the high error detection
overhead of Topaz for most benchmarks.

Figure 8: The overhead of performing error detection defined as the number of
cycles spent to perform error detection over the number of cycles required for
a fully reliable execution of the application Figure 9: Error detection and
correction overhead for batched error-checking

Figure 8 shows that the average error detection overhead with respect to the
execution time of the application on a reliable CPU is $13.83\%$ and $72.98\%$
for the best ANN (the one with the lowest EEOP), and Topaz, respectively. Note
that the output quality levels are the same as the first case study. Three
benchmarks (Blacksholes, Lulesh, inversej2k) have such a high detection
overhead, that the whole application is slowing down as shown in Table V. For
these benchmarks, Topaz is not a viable approach unless heavy task-batching is
utilized to amortize the cost of error detection. A similar trend is observed
across all benchmarks: performing error detection at a coarser level via
batching reduces the average overhead of error detection. More specifically,
the cost of error detection for ANNs after batching (Figure 9) comes to
$6.45\%$ and for Topaz to $12.81\%$. Error-detection for applications which
involve tasks with extremely small computational cost is only possible through
batching.

|  | Original | Batched
---|---|---|---
Benchmark | Oracle | ANN | Topaz | ANN | Topaz
DCT | 1.88 | 1.54 | 1.42 | 1.51 | 1.74
Sobel | 2.16 | 1.36 | 1.40 | 1.53 | 1.40
Blackscholes | 2.11 | 1.17 | 0.51 | 1.72 | 1.62
Bonds | 2.14 | 2.03 | 1.99 | 2.10 | 1.20
Lulesh | 1.93 | 1.21 | 0.35 | 1.48 | 1.16
Inversek2j | 2.06 | 1.39 | 0.43 | 1.85 | 1.41
Average | 1.99 | 1.51 | 1.15 | 1.72 | 1.44
TABLE V: Comparison of speedups obtained from simulating overclocked hardware
(($V_{nominal}$, $f_{overclocked}$) = ($0.9$ V, $3.7$ GHz)) vs the error-free
baseline ($0.9$ V, $1.67$ GHz)

##  VII Related work

Current state of the art approaches to online error detection rely on
duplicating the instructions of selected application parts which are
considered error-prone. Unsafe instructions are first identified via compiler-
analysis and/or profiling. Subsequently, a compiler pass hardens the
application by duplicating the unsafe instructions and inserting checks [14,
26, 12, 24]. The checks typically involve redundancy in the form of
instruction duplication. When a check detects an error the application is
restored using some earlier checkpoint. IPAS [24] expects the user to include
a verification function that is used to check whether an injected fault has
propagated to the output of the code which is targeted for software-hardening
against soft-errors. This function is only used to train an ANN that drives
the selection of instructions prior to their duplication. Other works [17, 16,
20] rely on manually implemented Light-Weight Checks (LWCs) to detect errors
at the outputs of computations. In [16] LWCs are used to determine when an
approximate alternative to a function computes outputs which severely differs
from the exact implementation. [20] relies on manually implemented LWCs to
detect errors on the output of unreliably executed code. [17] falls back to
instruction duplication whenever light-weight error detectors result in low
_Detection Coverage_.

[38] presents two offline debugging mechanisms and three online monitoring
mechanisms for approximate programs. The first offline mechanism identifies
correlation between Quality of Result (QoR) and each approximate operation by
tracking the execution and error frequencies of different code regions over
multiple program executions with varying QoR values. The second mechanism
tracks whether approximate operations affect some approximate variable and
memory location. The online mechanisms complement the offline ones and they
detect and compensate for QoR loss while maintaining the energy gains of
approximation. The first one compares the QoR for precise and approximate
variants of the program for a random subset of executions. This mechanism is
useful for programs where QoR can be assessed by sampling a few outputs, but
not for those that require bounding the worst-case errors. The second online
mechanism uses programmer-supplied _verification functions_ that check a
result with lower overhead than computing the result from scratch. The third
mechanism stores past inputs and outputs of the checked code to estimate the
output for current execution by interpolating past executions with similar
inputs. It is shown that the offline mechanisms help in effectively
identifying the root of a quality issue instead of merely confirming the
existence of an issue, and that the online mechanisms help in controlling QoR
while maintaining high energy gains. Our method may also detect errors due to
approximation but in this work we focus on errors induced by unreliable
execution.

[22] presents an output-quality monitoring and management technique which can
ensure meeting a given output quality. Based on the observation that simple
prediction approaches, (e.g. linear estimation, moving average, and decision
trees) can accurately predict approximation errors, they use a low-overhead
error detection module which tracks predicted errors to find the elements
which need correction. Using this information, the recovery module, which runs
in parallel to the detection module, re-executes the iterations that lead to
high-errors. This becomes possible since the approximable functions or codes
typically just simply read inputs and produce outputs without modifying any
other state, such as map and stencil patterns. Large errors on the
approximated computations are corrected by means of executing the accurate
code using the CPU. Our approach differs in that we use an ANN to detect error
whereas [22] uses hardware accelerated ANNs to approximate code whose output
is subsequently error checked.

In one of the chronologically earlier efforts on task-based error-tolerant
computing,[37] proposes a software mechanism that allows the programmer to
identify task blocks and then creates a profile-driven probabilistic fault
model for each task . This is accomplished by injecting faults at task
execution and observing the resulting output distortion and output failure
rates. The concept of Task Level Vulnerability (TLV) captures dynamic circuit-
level variability for each OpenMP task running in a specific processing core
[36]. TLV meta-data are gathered during execution by circuit sensors and error
detection units to provide characterization at the context of an OpenMP task.
Based on TLV meta-data, the OpenMP runtime apportions tasks to cores aiming at
minimizing the number of instructions that incur errors. Unlike our work, they
do not consider error recovery and user-specified approximate execution paths.

An earlier work [34] introduced an end-to-end framework for applications
comprising mixed-criticality computation parts on heterogeneous mixed-
reliability hardware. A programming model enables application developers
specify computation in the form of tasks which are tagged with significance
(criticality) information. At execution time, the most significant tasks are
scheduled on reliable hardware, and the least ones on unreliable hardware.
Unreliably executed tasks undergo a result-checking phase after their
termination. Tasks which are considered to have produced erroneous output are
then corrected either via re-execution or approximation. Error detection is
achieved through the use of manually implemented error-checking functions.

##  VIII Conclusions

We presented a methodology for constructing, in a largely automated way,
error-detectors that can identify, efficiently and effectively, erroneous
outputs of selected parts of a program (tasks) to facilitate fault tolerant
computing. We also provide a case study which exploits unreliable computing
with CPU cores configured near their PoFF to gracefully trade-off output
quality with performance. We employ light-weight error-detection through the
use of low overhead ANNs. Those ANNs detect errors at the outputs of
intermediate computations which would significantly impact the output quality
of the application. We showed that it is possible to rely on using ANNs for
automatic result-checking which outperforms the well known approximate outlier
detector Topaz [2]. For most of the investigated applications an ANN incurs
less computation overhead, and results in either better or equivalent output
quality compared to Topaz. In fact, ANNs outperform Topaz for real unreliable
execution for all the benchmarks that we tried on overclocked ARM Cortex A53
CPUs.

Moreover, we observed that batching can significantly reduce the overhead of
error detection. Unfortunately, that comes with a cost to the
_$\overline{MRE}$_. This increased _$\overline{MRE}$_ does not severely affect
the overall output quality of applications because the _Detection Coverage_ of
the error detectors tends to remain very high even with batching. Our
methodology enables a number of interesting future research directions for
designing dynamic runtime systems. For example, one can automatically generate
a number of error detectors which vary in terms of overhead and resulting
output quality. At execution time, the runtime system can choose the best
error detector depending on their EEOP, _$\overline{MRE}$_ scores, and user
supplied constraints such as a maximum energy budget for error detection.
Finally, our methodology generates small and lightweight ANNs which in turns
motivates the investigation of policies regarding fine-tuning during execution
time.

## References

  * [1] “Frequently found test images in literature,” available at http://www.imageprocessingplace.com/downloads_V3/root_downloads/image_databases/standard_test_images.zip.
  * [2] S. Achour and M. C. Rinard, “Approximate computation with outlier detection in topaz,” in _Proceedings of the 2015 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications_ , ser. OOPSLA 2015. New York, NY, USA: ACM, 2015, pp. 711–730. [Online]. Available: http://doi.acm.org/10.1145/2814270.2814314
  * [3] S. Amarasinghe, D. Campbell, W. Carlson, A. Chien, W. Dally, E. Elnohazy, M. Hall, R. Harrison, W. Harrod, K. Hill _et al._ , “Exascale software study: Software challenges in extreme scale systems,” _DARPA IPTO, Air Force Research Labs, Tech. Rep_ , 2009.
  * [4] Y. M. Assael, B. Shillingford, S. Whiteson, and N. de Freitas, “LipNet: Sentence-level Lipreading,” _arXiv preprint arXiv:1611.01599_ , 2016.
  * [5] A. Becker, T. Richter, N. Fröhling, P. Fraser, T. Story, W. J. Cosshall, D. Coffin, and B. Lindbloom, _Image Compression benchmark_ , 2015. [Online]. Available: http://imagecompression.info/test_images
  * [6] C. Bienia, “Benchmarking Modern Multiprocessors,” Ph.D. dissertation, Princeton University, January 2011.
  * [7] D. Blaauw, S. Kalaiselvan, K. Lai, W. Ma, S. Pant, C. Tokunaga, S. Das, and D. M. Bull, “Razor II: In Situ Error Detection and Correction for PVT and SER Tolerance,” in _IEEE Int. Solid-State Circuits Conference, ISSCC , Digest of Technical Papers_ , 2008.
  * [8] S. Borkar, “Designing reliable systems from unreliable components: The challenges of transistor variability and degradation,” _IEEE Micro_ , vol. 25, no. 6, pp. 10–16, Nov. 2005. [Online]. Available: http://dx.doi.org/10.1109/MM.2005.110
  * [9] F. Cappello, A. Geist, B. Gropp, L. Kale, B. Kramer, and M. Snir, “Toward exascale resilience,” _International Journal of High Performance Computing Applications_ , 2009.
  * [10] J. Constantin, L. Wang, G. Karakonstantis, A. Chattopadhyay, and A. Burg, “Exploiting Dynamic Timing Margins in Microprocessors for Frequency-over-scaling with Instruction-based Clock Adjustment,” in _Proc. of the Design, Automation & Test in Europe Conference & Exhibition_, 2015.
  * [11] S. Das, D. Roberts, S. Lee, S. Pant, D. Blaauw, T. Austin, K. Flautner, and T. Mudge, “A self-tuning DVS processor using delay-error detection and correction,” _Solid-State Circuits, IEEE Journal of_ , vol. 41, no. 4, 2006\.
  * [12] M. Didehban and A. Shrivastava, “nZDC: A Compiler technique for near Zero Silent data Corruption,” in _Proceedings of the 53rd Annual Design Automation Conference_. ACM, 2016, p. 48.
  * [13] H. Esmaeilzadeh, A. Sampson, L. Ceze, and D. Burger, “Neural Acceleration for General-Purpose Approximate Programs,” in _Proceedings of the 2012 45th Annual IEEE/ACM International Symposium on Microarchitecture_ , ser. MICRO-45. Washington, DC, USA: IEEE Computer Society, 2012, pp. 449–460. [Online]. Available: http://dx.doi.org/10.1109/MICRO.2012.48
  * [14] S. Feng, S. Gupta, A. Ansari, and S. Mahlke, “Shoestring: probabilistic soft error reliability on the cheap,” in _ACM SIGARCH Computer Architecture News_ , vol. 38, no. 1. ACM, 2010, pp. 385–396.
  * [15] S. Grauer-Gray, W. Killian, R. Searles, and J. Cavazos, “Accelerating financial applications on the GPU,” in _Proceedings of the 6th Workshop on General Purpose Processor Using Graphics Processing Units_. ACM, 2013, pp. 127–136.
  * [16] B. Grigorian and G. Reinman, “Dynamically adaptive and reliable approximate computing using light-weight error analysis,” in _Adaptive Hardware and Systems (AHS), 2014 NASA/ESA Conference on_. IEEE, 2014, pp. 248–255.
  * [17] S. K. S. Hari, S. V. Adve, and H. Naeimi, “Low-cost program-level detectors for reducing silent data corruptions,” in _Dependable Systems and Networks (DSN), 2012 42nd Annual IEEE/IFIP International Conference on_. IEEE, 2012, pp. 1–12.
  * [18] K. He, X. Zhang, S. Ren, and J. Sun, “Delving deep into rectifiers: Surpassing human-level performance on imagenet classification,” in _Proceedings of the IEEE international conference on computer vision_ , 2015, pp. 1026–1034.
  * [19] Y. Jia, E. Shelhamer, J. Donahue, S. Karayev, J. Long, R. Girshick, S. Guadarrama, and T. Darrell, “Caffe: Convolutional Architecture for Fast Feature Embedding,” _arXiv preprint arXiv:1408.5093_ , 2014.
  * [20] E. Kadric, K. Mahajan, and A. DeHon, “Energy reduction through differential reliability and lightweight checking,” in _Field-Programmable Custom Computing Machines (FCCM), 2014 IEEE 22nd Annual International Symposium on_. IEEE, 2014, pp. 243–250.
  * [21] I. Karlin, J. Keasler, and R. Neely, “LULESH 2.0 Updates and Changes,” Tech. Rep. LLNL-TR-641973, August 2013.
  * [22] D. S. Khudia, B. Zamirai, M. Samadi, and S. Mahlke, “Rumba: An online quality management system for approximate computing,” _SIGARCH Comput. Archit. News_ , vol. 43, no. 3, pp. 554–566, 2015.
  * [23] K. J. Kuhn, M. D. Giles, D. Becher, P. Kolar, A. Kornfeld, R. Kotlyar, S. T. Ma, A. Maheshwari, and S. Mudanai, “Process Technology Variation,” _IEEE Transactions on Electron Devices_ , vol. 58, no. 8, pp. 2197–2208, Aug 2011.
  * [24] I. Laguna, M. Schulz, D. F. Richards, J. Calhoun, and L. Olson, “Ipas: Intelligent protection against silent output corruption in scientific applications,” in _Proceedings of the 2016 International Symposium on Code Generation and Optimization_. ACM, 2016, pp. 227–238.
  * [25] Y. LeCun _et al._ , “Lenet-5, convolutional neural networks,” _URL: http://yann. lecun. com/exdb/lenet_ , 2015.
  * [26] Q. Lu, K. Pattabiraman, M. S. Gupta, and J. A. Rivers, “SDCTune: a model for predicting the SDC proneness of an application for configurable protection,” in _Compilers, Architecture and Synthesis for Embedded Systems (CASES), 2014 International Conference on_. IEEE, 2014, pp. 1–10.
  * [27] R. E. Lyons and W. Vanderkulk, “The use of triple-modular redundancy to improve computer reliability,” _IBM Journal of Research and Development_ , vol. 6, no. 2, pp. 200–209, 1962.
  * [28] L. McAfee and K. Olukotun, “EMEURO: A Framework for Generating Multi-purpose Accelerators via Deep Learning,” in _Proceedings of the 13th Annual IEEE/ACM International Symposium on Code Generation and Optimization_ , ser. CGO ’15. Washington, DC, USA: IEEE Computer Society, 2015, pp. 125–135. [Online]. Available: http://dl.acm.org/citation.cfm?id=2738600.2738616
  * [29] S. Misailovic, M. Carbin, S. Achour, Z. Qi, and M. C. Rinard, “Chisel: Reliability- and accuracy-aware optimization of approximate computational kernels,” _SIGPLAN Not._ , vol. 49, no. 10, pp. 309–328, Oct. 2014. [Online]. Available: http://doi.acm.org/10.1145/2714064.2660231
  * [30] S. S. Mukherjee, C. Weaver, J. Emer, S. K. Reinhardt, and T. Austin, “A systematic methodology to compute the architectural vulnerability factors for a high-performance microprocessor,” in _Proceedings of the 36th Annual IEEE/ACM International Symposium on Microarchitecture_ , ser. MICRO 36. Washington, DC, USA: IEEE Computer Society, 2003, pp. 29–. [Online]. Available: http://dl.acm.org/citation.cfm?id=956417.956570
  * [31] S. Narayanan, J. Sartori, R. Kumar, and D. L. Jones, “Scalable Stochastic Processors,” in _Proceedings of the Conference on Design, Automation and Test in Europe_ , ser. DATE ’10. 3001 Leuven, Belgium, Belgium: European Design and Automation Association, 2010, pp. 335–338. [Online]. Available: http://dl.acm.org/citation.cfm?id=1870926.1871008
  * [32] E. Normand, “Single-event effects in avionics,” _IEEE Transactions on nuclear science_ , vol. 43, no. 2, pp. 461–474, 1996.
  * [33] K. Parasyris, V. Vassiliadis, C. D. Antonopoulos, S. Lalis, and N. Bellas, “A Framework for Evaluating Software on Reduced Margins Hardware,” in _Proceedings of the 2018 International Conference on Dependable Systems and Networks (DSN2018)_.
  * [34] ——, “Significance-Aware Program Execution on Unreliable Hardware,” _ACM Trans. Archit. Code Optim._ , vol. 14, no. 2, pp. 12:1–12:25, Apr. 2017\. [Online]. Available: http://doi.acm.org/10.1145/3058980
  * [35] J. Patel, “Cmos process variations: A critical operation point hypothesis,” in _Online Presentation_ , 2008.
  * [36] A. Rahimi, A. Marongiu, P. Burgio, R. K. Gupta, and L. Benini, “Variation-tolerant OpenMP Tasking on Tightly-coupled Processor Clusters,” in _DATE ’13_. EDA Consortium, 2013, pp. 541–546.
  * [37] M. Rinard, “Probabilistic Accuracy Bounds for Fault-tolerant Computations That Discard Tasks,” in _ICS ’06_. ACM, 2006, pp. 324–334.
  * [38] M. Ringenburg, A. Sampson, I. Ackerman, L. Ceze, and D. Grossman, “Monitoring and debugging the quality of results in approximate programs,” in _ASPLOS ’15_. ACM, 2015, pp. 399–411.
  * [39] J. Sartori and R. Kumar, “Alleviating voltage scaling limitations of razorbased designs,” in _Proceedings of the 18th IEEE Workshop on Logic and Synthesis (IWLS 2009)_ , 2009.
  * [40] J. Shalf, S. Dosanjh, and J. Morrison, “Exascale computing technology challenges,” in _High Performance Computing for Computational Science – VECPAR 2010_ , ser. Lecture Notes in Computer Science, J. Palma, M. Daydé, O. Marques, and J. Lopes, Eds. Springer Berlin Heidelberg, 2011, vol. 6449, pp. 1–25. [Online]. Available: http://dx.doi.org/10.1007/978-3-642-19328-6_1
  * [41] V. Vassiliadis, J. Riehme, J. Deussen, K. Parasyris, C. D. Antonopoulos, N. Bellas, S. Lalis, and U. Naumann, “Towards automatic significance analysis for approximate computing,” in _Proceedings of the 2016 International Symposium on Code Generation and Optimization_ , ser. CGO 2016\. New York, NY, USA: ACM, 2016, pp. 182–193. [Online]. Available: http://doi.acm.org/10.1145/2854038.2854058
  * [42] N. J. Wang, J. Quek, T. M. Rafacz, and S. J. patel, “Characterizing the Effects of Transient Faults on a High-Performance Processor Pipeline,” in _Proceedings of the 2004 International Conference on Dependable Systems and Networks_ , ser. DSN ’04. Washington, DC, USA: IEEE Computer Society, 2004, pp. 61–. [Online]. Available: http://dl.acm.org/citation.cfm?id=1009382.1009722
  * [43] A. Yazdanbakhsh, D. Mahajan, P. Lotfi-Kamran, and H. Esmaeilzadeh, “AXBENCH: A Multi-Platform Benchmark Suite for Approximate Computing,” _IEEE Design & Test_, 2016.
  * [44] J. Ziegler and H. Puchner, _SER – History, Trends and Challenges: A guide for designing with Memory ICs_. Cypress, 2004.


# The splitting of directed flow for identified light hadrons ($K$ and $p$)
and strange baryons ($\Xi$ and $\Omega$) in Au+Au collisions at STAR ††thanks:
Presented at 29th International Conference on Ultra-relativistic Nucleus-
Nucleus Collisions (Quark Matter 2022), Krakow, Poland

Ashik Ikbal Sheikh (for the STAR Collaboration)  Department of Physics, Kent
State University,
Kent, OH 44242, USA
Email<EMAIL_ADDRESS><EMAIL_ADDRESS>
###### Abstract

The first measurements for rapidity-odd directed flow of $\Xi$ and $\Omega$ in
Au+Au collisions at $\sqrt{s_{\mathrm{NN}}}=$ 27 and 200 GeV are reported. The
coalescence sum rule is examined with various combinations of hadrons where
all constituent quarks are produced, such as
$K^{\\!{}^{-}}\\!\\!({\bar{u}}{s})$, $\bar{p}({\bar{u}\bar{u}}{\bar{d}})$,
$\bar{\Lambda}(\bar{u}\bar{d}\bar{s})$, $\phi({s}{\bar{s}})$,
$\overline{\Xi}^{+}(\bar{d}\bar{s}\bar{s})$, ${\Omega}^{-}(sss)$, and
$\overline{\Omega}^{+}(\bar{s}\bar{s}\bar{s})$. For such combinations, a
systematic violation of the sum rule is observed with increasing difference in
the electric charge and the strangeness content of the combinations.
Measurements are compared with the calculations of A Multi-Phase Transport
(AMPT) model and Parton-Hadron String Dynamics (PHSD) model with
electromagnetic (EM) field. The PHSD model with EM field agrees with the
measurements within uncertainties.

##  1 Introduction

Directed flow ($v_{1}$) is the first harmonic coefficient in the Fourier
expansion of the final-state azimuthal distribution relative to the reaction
plane. Theoretical calculations [1] based on nuclear transport and
hydrodynamics indicate that the $v_{1}$ is sensitive to the early stages of
the high energy heavy-ion collisions.

One of the most important features of the early stages of the heavy-ion
collisions is the production of an extremely strong magnetic field due to the
motion of the charged spectators. The produced magnetic field decays down fast
since the charged spectators fly away from the collision zone and this
generates an electric current in the plasma due to the Faraday effect. In
addition, the plasma has a longitudinal expansion velocity along the beam
direction and perpendicular to magnetic field direction, hence the Lorentz
force pushes charged particles and anti-particles of the plasma in opposite
ways which are perpendicular to both the directions of longitudinal velocity
of plasma and the magnetic field. This is analogous to Hall effect. The
charged spectators can also generate an electric current in the plasma due to
Coulomb effect. The $v_{1}$ of different produced charged particles is greatly
influenced by the resultant of Faraday, Hall, and Coulomb effects which
eventually leads to the splitting of $v_{1}$ [2]. Both STAR and ALICE
experiments measured a non-zero $v_{1}$ splitting with pseudo-rapidity between
positively and negatively charged hadrons in Au+Au collisions at
$\sqrt{s_{\mathrm{NN}}}=$ 200 GeV [3] and Pb+Pb collisions at
$\sqrt{s_{\mathrm{NN}}}=$ 2.76 TeV [4], respectively. However, the
interpretation of the measured splitting using charged hadrons runs into
difficulties especially when the effects of electromagnetic fields are
concerned. This is due to the fact that among light hadrons, there are many
(anti-)particles containing $u$ and $d$ quarks, which can be either
transported from beam rapidity [5] or produced in the collisions. Due to the
different number of interactions suffered, the transported $u$ and $d$ have
different $v_{1}$ than those of the produced quarks [6]. This ensures a pre-
existing splitting due to the transport. This transport driven splitting is a
background in search of the pure electromagnetic-field-driven splitting. We
could avoid the transported quarks in our analysis by selecting particles
composed of produced constituent quarks only ($\bar{u}$, $\bar{d}$, $s$, and
$\bar{s}$). The experimental method is outlined briefly in Sec. 2.

In this contribution, we report the measurements of $v_{1}$ of multi-strange
baryons ($\Xi$ and $\Omega$). The $v_{1}$-splitting as a function of electric
charge difference ($\Delta q$) and strangeness difference ($\Delta S$) is
measured, using $K^{-}$, $\bar{p}$, $\bar{\Lambda}$, $\phi$,
$\overline{\Xi}^{+}$, $\Omega^{-}$, and $\overline{\Omega}^{+}$ from Au+Au
collisions at $\sqrt{s_{\mathrm{NN}}}=27$ and $200$ GeV.

##  2 Data sets and Analysis strategy

STAR detector system is versatile experimental setup for track reconstruction,
vertexing, and particle identification at RHIC. The main sub-detectors are (i)
Time Projection Chamber (TPC) ($|\eta|\leq 1$): used for charged particle
tracking, vertexing, and particle identification; (ii) Time-Of-Flight (TOF)
detector: used for particle identification; (iii) Event-Plane Detectors (EPDs)
($2.1<|\eta|<5.1$) and (iv) Zero-Degree Calorimeter with Shower-Maximum
Detectors (ZDC-SMDs) ($|\eta|>6.3$): can measure event planes of the
collisions.

A high statistics data samples for Au+Au collisions
at$\sqrt{s_{\mathrm{NN}}}=$ 27 and 200 GeV are used in the measurements. We
use events with the vertex position along the beam direction with
$|V_{\mathrm{z}}|<70$ cm, and along the radial directions, $V_{r}<2$ cm at
$\sqrt{s_{\mathrm{NN}}}=27$ GeV; and $|V_{z}|<30$ cm, $V_{\mathrm{r}}<2$ cm at
$\sqrt{s_{\mathrm{NN}}}=$ 200 GeV. At the track level,
$p_{\mathrm{T}}\\!>\\!0.2$ GeV/$c$, and a distance of closest approach (DCA)
from vertex, $\rm{DCA}\leq 3$ cm, and at least 15 space points in the TPC
acceptance are selected. For particle identification, we use
$p_{\mathrm{T}}\\!>\\!0.2$ GeV/$c$, momentum $<1.6$ GeV/$c$ and
$|n_{\sigma}|\leq 2$ for charged pions and kaons;
$\\!0.4<p_{\mathrm{T}}\\!<\\!5$ GeV/$c$, $|n_{\sigma}|\leq 2$ for $p$ and
$\bar{p}$, where $n_{\sigma}$ is the standard deviation of difference between
measured $\langle dE/dx\rangle$ and theoretical mean value for each particle
type. The $\Lambda$, $\bar{\Lambda}$, ${\Xi}^{-}$, $\overline{\Xi}^{+}$,
${\Omega}^{-}$, and $\overline{\Omega}^{+}$ are reconstructed using KF-
Particle package [7]. The $\phi$-mesons are reconstructed in $K^{+}K^{-}$
channel using the invariant mass method with pair rotation background
subtraction. The systematic uncertainties on the measurements are obtained by
varying these analysis cuts. We remove the effect of the statistical
fluctuations by employing Barlow’s method [8].

The analysis method is based on the quark coalescence mechanism. Coalescence
sum rule states that the directed flow of a hadron is consistent with the sum
of the directed flow of its constituent quarks, $\it{i.e.}$, $v_{1}({\rm
hadron})=\sum\limits_{i}v_{1}(q_{i})$, where the sum runs over the $v_{1}$ of
the constituent quarks, $q_{i}$. There are many hadron species composed of
constituent $u$ and $d$ quarks, which might or might not be transported from
the incoming nuclei. The transported quarks produce background in search of
the possible electromagnetic-field-driven $v_{1}$ splitting. Hence, in the
analysis we take particles which contain produced quarks only, namely,
$K^{\\!{}^{-}}\\!\\!({\bar{u}}{s})$, $\bar{p}({\bar{u}\bar{u}}{\bar{d}})$,
$\bar{\Lambda}(\bar{u}\bar{d}\bar{s})$, $\phi({s}{\bar{s}})$,
$\overline{\Xi}^{+}(\bar{d}\bar{s}\bar{s})$, ${\Omega}^{-}(sss)$, and
$\overline{\Omega}^{+}(\bar{s}\bar{s}\bar{s})$. All these particles have
different flavour, electric charge ($q$) and mass ($m$); and $v_{1}$ is
sensitive to quark flavour and mass. Keeping this in mind, we combine the
different particles so that combinations have same or similar mass at the
constituent quark level ($\Delta m\approx 0$), but $\Delta q\neq 0$ and
$\Delta S\neq 0$. We found five independent combinations as shown in Table 1.
The difference $\Delta v_{1}$ of such combinations is called “splitting of
$v_{1}$” [9] and the slope of the $\Delta v_{1}$ vs. rapidity is a measure of
the splitting. We measure the $\Delta v_{1}$ of all the indices in Table 1 to
obtain the splitting as a function of $\Delta q$, a measure of EM-field-driven
splitting. At the same time, we also measure the the $\Delta v_{1}$ with
$\Delta S$ of all the combinations. Although, the change in $\Delta q$ is also
associated with a change in $\Delta S$ in Table 1 which comes from the quantum
numbers carried by the constituent quarks.

Index | Quark mass |  | Charge |  | Strangeness |  $\Delta v_{1}$ combination
---|---|---|---|---|---|---
1 | $\Delta m=0$ |  | $\Delta q=0$ |  | $\Delta S=0$ | ${[\bar{p}({\bar{u}\bar{u}}{\bar{d}})+\phi({s}{\bar{s}})]}-[K^{\\!{}^{-}}\\!\\!({\bar{u}}{s})+\bar{\Lambda}(\bar{u}\bar{d}\bar{s})]$
2 | $\Delta m\approx 0$ |  | $\Delta q=1$ |  | $\Delta S=2$ | ${[\bar{\Lambda}(\bar{u}\bar{d}\bar{s})]}-[\frac{1}{3}{\Omega}^{-}(sss)+\frac{2}{3}\bar{p}({\bar{u}\bar{u}}{\bar{d}})]$
3 | $\Delta m\approx 0$ |  | $\Delta q=\frac{4}{3}$ |  | $\Delta S=2$ | ${[\bar{\Lambda}(\bar{u}\bar{d}\bar{s})]}-[K^{\\!{}^{-}}\\!\\!({\bar{u}}{s})+\frac{1}{3}\bar{p}({\bar{u}\bar{u}}{\bar{d}})]$
4 | $\Delta m=0$ |  | $\Delta q=2$ |  | $\Delta S=6$ | ${[\overline{\Omega}^{+}(\bar{s}\bar{s}\bar{s})]}-[{\Omega}^{-}(sss)]$
5 | $\Delta m\approx 0$ |  | $\Delta q=\frac{7}{3}$ |  | $\Delta S=4$ | ${[\overline{\Xi}^{+}(\bar{d}\bar{s}\bar{s})]}-[K^{\\!{}^{-}}\\!\\!({\bar{u}}{s})+\frac{1}{3}{\Omega}^{-}(sss)]$
Table 1: Table showing difference in mass, charge, and strangeness between
combinations formed from seven particle species composed of produced quarks
only.

##  3 Results and Discussions

Figure 1 displays the first measurements of $\Xi$ and $\Omega$ baryon $v_{1}$
in 10%-40% central Au+Au collisions at $\sqrt{s_{NN}}=27$ and $200$ GeV. We
perform a linear fit, $v_{1}(y)=Cy$, where $C$ is the fitting parameter, and
$y$ is the rapidity. We found: $C=-0.0083\pm 0.0020~{}(\rm{stat.}\pm
0.00~{}(\rm{syst.}))$ $[-0.0148\pm 0.0028~{}(\rm{stat.})\pm
0.0013~{}(\rm{syst.})]$ for $\Xi^{-}$ [$\overline{\Xi}^{+}$] and $C=-0.0214\pm
0.008~{}(\rm{stat.})\pm 0.0034~{}(\rm{syst.})$ $[-0.0075\pm
0.0118~{}(\rm{stat.})\pm 0.0017~{}(\rm{syst.})]$ for $\Omega^{-}$
[$\overline{\Omega}^{+}$] at $\sqrt{s_{NN}}=27$ GeV. There is a hint of a
larger $v_{1}$ for ${\Omega}^{-}$ compared to $\Xi$ baryons is observed at
$\sqrt{s_{\mathrm{NN}}}=27$ GeV, though the uncertainties are large.

Figure 1: $v_{1}$ of $\Xi^{-}$, $\overline{\Xi}^{+}$, ${\Omega}^{-}$ and
$\overline{\Omega}^{+}$ as a function of rapidity, $y$, in 10%-40% central
Au+Au collisions at $\sqrt{s_{\mathrm{NN}}}=27$ and $200$ GeV.

In Fig. 2, we show the measured $\Delta v_{1}(y)$ for hadron combinations with
($\Delta q$, $\Delta S$) $=$ (0, 0), (4/3, 2) in 10%-40% Au+Au collisions at
$\sqrt{s_{\mathrm{NN}}}=27$ GeV. The $\Delta v_{1}$-slope parameters of the
measurements are extracted. For $\Delta q=0$ and $\Delta S=0$ (identical quark
combination case), the value of the slope is a minimum compared to $\Delta q$
= 4/3 and $\Delta S$ = 2 cases. This minimum deviation from zero implies that
the coalescence sum rule holds with the identical quark combination. The
deviation of the slope from zero increases as we move to $\Delta q$ = 4/3 and
$\Delta S$ = 2 case. A Multi-Phase Transport (AMPT) [10, 11] model calculation
can describe the measured $\Delta v_{1}$ within errors for the $\Delta q=0$,
$\Delta S=0$ case. For $\Delta q$ = 4/3 and $\Delta S$ = 2, AMPT depicts a
completely opposite trend compared to the data.

Figure 2: $\Delta v_{1}$ as a function of $y$ for ($\Delta q$, $\Delta S$) $=$
(0, 0), (4/3, 2) in Au+Au collisions at $\sqrt{s_{\mathrm{NN}}}=27$ GeV in
10%-40% centrality.

Figure 3: $\Delta v_{1}$-slope ($d\Delta v_{1}/dy$) as a function of $\Delta
q$, and $\Delta S$ for 10%-40% centrality in Au+Au collisions at
$\sqrt{s_{\mathrm{NN}}}=27$ GeV and $\sqrt{s_{\mathrm{NN}}}=27$ GeV.

In Fig. 3, we display the mid-rapidity $\Delta v_{1}$-slope ($d\Delta
v_{1}/dy$) as a function of $\Delta q$ and $\Delta S$ for 10%-40% central
Au+Au collisions at $\sqrt{s_{\mathrm{NN}}}=27$ and 200 GeV. The $d\Delta
v_{1}/dy$ increases with $\Delta q$ and $\Delta S$. The slope parameters of
the $d\Delta v_{1}/dy$ with $\Delta q$, $d^{2}\Delta v_{1}/dy\,d\Delta q$, are
$[2.952\pm 0.489~{}(\rm{stat.})\pm 0.367~{}(\rm{syst.})]\times 10^{-3}$ and
$[1.242\pm 0.381~{}(\rm{stat.})\pm 0.258~{}(\rm{syst.})]\times 10^{-3}$ at
$\sqrt{s_{\mathrm{NN}}}=27$ and 200 GeV, respectively. The magnitude of the
$\Delta v_{1}$ slope is larger at $\sqrt{s_{\mathrm{NN}}}=27$ GeV than at 200
GeV with $4.83\sigma$ significance. The AMPT calculations [10, 11] do not
agree with the measurements whereas the PHSD with EM field calculations can
explain the data within uncertainties. The PHSD model with EM field assumes
that all electric charges are affected by the strong EM field which ensures
splitting of $v_{1}$ between positive and negative particles as observed in
Fig 3.

##  4 Summary

In summary, we present the first measurements of directed flow, $v_{1}(y)$, of
$\Xi$ and $\Omega$ in Au+Au collisions at $\sqrt{s_{\mathrm{NN}}}=27$ GeV and
200 GeV. There is a hint of a relatively larger $v_{1}$-slope for $\Omega^{-}$
compared to the $\Xi$ baryons within the uncertainties. We measure directed
flow splitting, $\Delta v_{1}$, with $\Delta q$ and $\Delta S$. The $\Delta
v_{1}$-slope for hadron combinations, increases with $\Delta q$ and $\Delta
S$. The strength of the splitting increases going from
$\sqrt{s_{\mathrm{NN}}}=$ 200 to 27 GeV. The PHSD with EM field calculations
can describe the $\Delta q$ and $\Delta S$ dependent splitting within
uncertainties.

## Acknowledgments

Author acknowledges support from the Office of Nuclear Physics within the US
DOE Office of Science, under Grant DE-FG02-89ER40531.

## References

  * [1] U. W. Heinz, Landolt-Bornstein, 23, 240 (2010).
  * [2] U. Gursoy et al., Phys. Rev. C 89, 054905 (2014); Phys. Rev. C 98, 055201 (2018).
  * [3] STAR Collaboration, Phys. Rev. Lett. 118, 012301 (2017).
  * [4] ALICE Collaboration, Phys. Rev. Lett. 125, 022301 (2020).
  * [5] J. C. Dunlop, M. A. Lisa, and P. Sorensen, Phys. Rev. C 84, 044914 (2011).
  * [6] Y. Guo, F. Liu, and A. Tang, Phys. Rev. C 86, 044901 (2012).
  * [7] S. Gorbunov, On-line reconstruction algorithms for the CBM and ALICE experiments, Ph.D. thesis, Johann Wolfgang Goethe-Universitat (2013).
  * [8] R. Barlow, in Conference on Advanced Statistical Techniques in Particle Physics(2002), hep-ex/0207026.
  * [9] A. I. Sheikh, D. Keane, and P. Tribedy, Phys. Rev. C 105, 014912 (2022).
  * [10] Z.-W. Lin et al., Phys. Rev. C 72, 064901 (2005).
  * [11] K. Nayak, S. Shi, N. Xu, and Z.-W. Lin, Phys. Rev. C 100, 054903 (2019).