# Griffin: Fast Transactional Database Index
with Hash and B+-Tree

Sho Nakazono1 Hideyuki Kawashima  Computer and Data Science Laboratories
NTT
Tokyo, Japan
Faculty of Environment and Information Studies
Keio University
Kanagawa, Japan
Yutaro Bessho2 Tatsuhiro Nakamori  Computer and Data Science Laboratories
NTT
Tokyo, Japan
Faculty of Environment and Information Studies
Keio University
Kanagawa, Japan

###### Abstract

Index access is one of the dominant performance factors in transactional
database systems. Many systems use a B+-tree or one of its variants to handle
point and range operations. This access pattern has room for performance
improvement. Firstly, point operations can potentially be processed in $O(1)$
with a hash table. Secondly, to ensure serializability of transactions, range
operations incur overhead from phantom avoidance techniques that involve
additional processing or synchronization, such as an extra traversal of the
B+-tree. To address these issues, we propose a hybrid index architecture,
Griffin. For point operations, Griffin has a hash table that provides access
paths in $O(1)$ time, along with a B+-tree. For phantom avoidance, Griffin
employs a precision locking method, which does not involve additional
traversal of the B+-tree. Despite its hybrid architecture, Griffin
transparently provides linearizable operations and an interface of a single
database index. We built a Griffin index combining a hash table and BwTree.
Compared to a baseline index that is composed of a BwTree only, it achieves up
to 3.1x higher throughput in a point operation dominant workload, and up to
5.4x higher throughput in a range operation dominant workload.

###### Index Terms:

Database Index, Transaction Processing, Phantom Anomaly

11footnotetext: Currently, LY corporation.22footnotetext: Corresponding
author: Yutaro Bessho (e-mail: yutaro.bessho@ntt.com).

##  I Introduction

###  I-A Motivation

Data-driven scientific applications require massive amounts of data, and thus,
indexing has been studied to accelerate access to data [1, 2]. For example,
large scientific data is usually managed with distributed file systems on a
cluster of machines, and the performance of modern distributed file systems
depends on that of its metadata server [3, 4, 5]. Since accesses to the server
are transactional, accelerating transactional index has been studied.
Transactional indexes are required to handle both point operations and range
operations efficiently.

The design of efficient index structures has been studied extensively in
database systems literature, and it has been shown that index structures have
a crucial effect on performance. A study shows that index access constitutes
14-94 % of the total processing time in a transactional database [6]. The most
commonly used index data structure is the B+-tree. According to an open
database systems catalog [7], 60 out of 87 systems employ a B+-tree or one of
its variants. The conventional practice for adopting a B+-tree is to have it
provide $O(\log N)$ access paths for both point operations and range
operations, where $N$ denotes the total number of elements (i.e., table size).
This design pattern has room for performance improvement.

###  I-B Issues of B+-tree

Issue 1: Point Operation Performance. As point operations do not inherently
require that the keys be ordered inside the data structure, they can
potentially be processed in $O(1)$ time with a hash table [8]. However, simply
replacing the B+-tree with a hash table significantly hurts range operation
performance. The unordered nature of a hash table demands a full scan
regardless of the selectivity of the operation. Moreover, supporting range
operations in transactions requires the elimination of phantoms [9], a type of
correctness violation in transactions. To our knowledge, no techniques have
been proposed to eliminate it with a hash table alone.

Issue 2: Range Operation Performance. The techniques widely used to eliminate
phantoms can impose significant overhead on range operations, such as scans.
To avoid phantoms, modern systems use a validation-based method called
rescanning. For example, in Hekaton [10] and Silo [11], when a transaction
tries to commit, it repeats the record scans it has done to validate that the
scanning results have not changed. The transaction is aborted when any change
is detected, preventing phantoms. This method doubles the calculation costs of
scans, each of which consists of a vertical (navigating to a first leaf node:
$O(\log N)$) and horizontal (scanning through the read set: $O(M)$, where $M$
is the read set size) tree traversal.

###  I-C Proposal

To address these performance issues, we propose an indexing architecture
called Griffin. Fig. 1 summarizes the architecture of Griffin. The Griffin
index consists of a hash table and a B+-tree. As opposed to the singular
B+-tree architecture, the hash table addresses Issue 1 by providing access
paths for point operations in $O(1)$ time.

Griffin addresses Issue 2 by avoiding phantoms without rescanning. Griffin
adopts a lightweight phantom avoidance technique based on precision locking
[12]. Inserts and deletes post their access keys to a bookkeeping set shared
among transactions. Before a scan accesses the B+-tree, it searches the set
for any conflicting insert or delete keys that conflict with the scan range.
The scan is allowed to proceed if no conflict is found, or aborted otherwise.
This method is advantageous in that it does not involve an extra B+-tree
traversal.

Griffin provides an interface of a single database index despite the hybrid
architecture. Griffin integrates the different index structures and precision
locking in a manner that all operations are linearizable [13]. Updates
(inserts and deletes) take effect on the hash table first, and then
periodically get propagated to the B+-tree. Even though the B+-tree does not
always reflect all recent updates, the staleness is mitigated with a
synchronization thread that periodically propagates updates to the B+-tree.
Remaining stale (non-linearizable) reads are detected and aborted, by taking
advantage of the precision locking-based phantom avoidance mechanism.

We built an index based on the Griffin architecture with a lock-free hash
table [14] and OpenBwTree [15], an open-source implementation of Bw-Tree [16].
We compared the performance of Griffin with a baseline system, which is a
B+-tree variant (Bw-Tree) that avoids phantoms through rescanning. We found
that, in a workload that consists of point operations only (YCSB-A), Griffin
resulted in a peak throughput 3.1x as high as the baseline. We also observed a
peak throughput 5.4x as high as the baseline, in a mixture of point and range
operations (YCSB-E).

Figure 1: Griffin index architecture.

###  I-D Organization

The rest of this paper is organized as follows: In Sec.II, we explain the
preliminaries of database indexes and phantom avoidance techniques. In
Sec.III, we introduce our proposed method, Griffin. In Sec.IV, we show our
implementation of our method used in the evaluation. In Sec.V, we present
experimental results on the YCSB benchmark. In Sec.VI, we discuss related
work. In Sec.VII, we summarize our findings and suggest future work.

##  II Preliminaries

###  II-A Index Operations: Point and Range

We assume a database system that supports serializable transactions. A
transaction invokes at least one index operation. An operation may abort in
the event of conflicts with other operations. In such cases, the transaction
that initiated the operation will also abort. Tab. I shows the minimum
operation set that indexes in databases need to process [17, 18]. These
operations, excluding Griffin operations for now, can be broadly divided into
two types: point operations (Lookup, Insert, and Delete) and range operations
(Scan).

A point operation takes a single key, while a Scan takes a search predicate
that represents a key range. A database concurrently processes a mixture of
operations in its workload and sends them to its indexes. For example, in
applications such as self-driving vehicles, a database sends a mixture of
Lookups and Scans to its indexes; a Lookup returns a data item representing a
vehicle whose location information is to be updated, and a Scan returns the
locations of vehicles nearby. In another example system that saves server
access logs, Inserts are executed at a high rate and Lookups and Scans rarely
happen. Indexes are required to efficiently handle such diverse workloads.

The implementation and performance characteristics of these interfaces vary
greatly depending on the underlying data structures. Hash tables are highly
efficient for point operations with an amortized computational complexity of
$O(1)$. However, they require $O(N)$ full scans for range queries. B+-trees
have a relatively low computational complexity of $O(\log N)$ for any
operation, making them efficient enough for range operations. However, since
point operations such as Lookup are more common in recent applications, the
performance penalty of not being $O(1)$ is significant [19].

TABLE I: Index operations invoked by the database. Griffin operations will be
explained in Sec.III-D. Point Operations
---
|  Lookup($k$) | Returns the data corresponding to a given key $k$
|  Insert($k$) | Creates data corresponding to a given key $k$
|  Delete($k$) | Removes the data corresponding to a given key $k$
Range Operation
|  Scan($r$) | Returns all data in the given key range $r$, where $r$ is a single key range (e.g., "a" - "z" )
Griffin Operations
|  Commit() | Notifies the index that a transaction has been committed
|  Abort() | Notifies the index that a transaction has been aborted

###  II-B Correctness: Linearizability and Serializability

A general design pattern in transactional databases is that indexes are tasked
with satisfying two correctness requirements: ensuring linearizability [13] of
operations and eliminating phantoms [9]. Linearizability is a property of
operation scheduling. It requires that the ordering (scheduling) of operations
be consistent with the wall-clock time ordering. This property precludes stale
reads, which are reading of old states of the index. For example, without
linearizability, a client of a distributed system may see an old status of
directories.

In transactional databases, indexes must also provide a protocol that
eliminates phantoms, which is necessary for guaranteeing serializability [9,
20]. Phantoms occur when operations that manipulate data existence (Inserts
and Deletes) run concurrently with predicate-based reads (Scans) and cause
Scans to get inconsistent results [21]. For example, consider two vehicles
running in the same direction in each neighboring lane. One of them executes
two Scans to obtain vehicle data from two lanes in a single transaction, and
the other vehicle changes lanes simultaneously (i.e., executes an Insert to
the destination lane and Delete from the old lane). A phantom causes the
vehicle that has performed the scans to read an intermediate state, i.e., it
fails to detect the other vehicle in either lane, although it in fact is
veering into the same lane.

###  II-C Phantom Avoidance Techniques

The techniques for phantom avoidance are classified into two categories.

####  II-C1 B+-Tree

##### Next-key locking

Databases such as MySQL [22] and DB2 [23] adopt the next-key locking method
[24] in their indexes for phantom avoidance. This method acquires two locks
for each record being accessed. One of them is a lock on the record itself
(e.g., a leaf node in the B+-tree) and the second lock is acquired on the
pointer to the next record. Scans detect the existence of concurrent Inserts
and Deletes by finding these locks and wait for them to be unlocked. Next-key
locking has the problem of low concurrency because it acquires two locks for
every record it accesses [11, 25].

##### Rescanning

Modern transactional database systems employ an optimistic method that avoids
locking to fully leverage the parallelism of multiprocessor hardware. Hekaton
[26] and Silo [11] perform a validation process based on the optimistic
concurrency control [27]. This technique performs Scans without extra locking
in the B+-tree and instead stores the ranges of Scans in transaction-local
variables. It then uses rescanning validation where it executes a scan on the
same ranges again at commit time. The validation process checks if the results
of the two scans match (i.e., there have been no Inserts and Deletes
conflicting with the scan ranges). Since rescanning does not use locks, its
concurrency is higher than next-key locking. However, the two-fold scanning is
costly when the read set is large [25].

Next-key locking and rescanning are widely adopted by databases with tree
indexes because they support both point search and range search, though its
point search cost ($O(logN)$) is less efficient than hash search ($O(1)$).

####  II-C2 Precision Locking

The second technique uses a special data structure called precision locking
[12]. Databases such as Hyper [28] and AOCC [25] employ precision locking
[12], which is an extension of predicate locking [9].

In precision locking, Inserts, Deletes, Scans, i.e., operations that can cause
phantoms, are guarded with a logical lock associated with the key (or key
range) they access. This lock prevents other transactions from executing a
data operation that accesses a conflicting key (or key range.) This lock is
acquired before the actual insert/delete/scan, and released after the
transaction that issued the operation terminates.

TABLE II: The $L_{u}$ and $L_{p}$ sets in precision locking. $L_{u}$ | Set of updated keys (Inserts and Deletes)
---|---
$L_{p}$ | Set of read predicates (Scans)

The logical locks are managed in two sets, $L_{u}$ and $L_{p}$ (terminology in
accordance with [9]). These sets have entries that each represent a logical
lock. As shown in Tab. II, $L_{u}$ is a set of entries for Inserts and
Deletes, and $L_{p}$ for Scans. We (and [9]) assume each Scan has a read
predicate that is a single key range. An Insert or Delete first adds its entry
that contains the accessed key to $L_{u}$, and searches $L_{p}$ to detect any
range that overlaps with the inserted or deleted key. The operation is able to
proceed if no conflicts are found, or waits (or gets aborted) otherwise. A
Scan follows a similar procedure: it first adds its entry that contains the
scanned range (predicate) to $L_{p}$, searches $L_{u}$ for conflicting keys.

###  II-D Properties of Data Structures

TABLE III: Summary of data structure properties. $N$ represents the total number of elements stored, $M$ the number of elements returned by a Scan, $|L_{u}|,|L_{p}|$ the sizes of precision locking sets $L_{u},L_{p}$, respectively. Note that range operations (Scans) in B+-tree entail double the execution costs of a vertical ($O(logN)$) and horizontal ($O(M$)) traversal, because it involves rescanning at commit time for phantom avoidance. | Operation | Hash | B+-Tree | Precision Locking | Griffin
---|---|---|---|---|---
Point Operation Costs | Lookup | $O(1)$ | $O(\log N)$ | None | $O(1)$
Insert/Delete | $O(1)+O(|L_{p}|)$
Range Operation Costs | Scan | $O(N)$ | $2\times(O(\log N)+O(M))$ | None | $O(|L_{u}|)+O(\log N)+O(M)$
Phantom Avoidance | - | No | Yes | Yes | Yes

In Tab. III, we summarize the properties of hash, B+-tree (that avoids
phantoms with rescanning), and precision locking from the perspectives of
point operation costs, range operation costs, and phantom avoidance. Hash
provides the fastest point operations, while it requires a full search in a
Scan and does not provide phantom avoidance. B+-tree with rescanning provides
$O(\log N)$ point operations, which we have discussed are not optimal (Sec. I,
Issue 1). It provides range operations, but they entail rescanning overhead
for phantom avoidance. Precision locking provides neither point search nor
range search, because its data structures ($L_{u}$ and $L_{p}$) themselves do
not provide access paths as hash and tree indexing methods do.

If we could use hash for point search, tree for range search, and precision
locking for phantom avoidance without rescanning, it might be a most efficient
structure.

##  III Griffin

Figure 2: Data structure and control flow of Griffin. Griffin has an always
up-to-date hash table and an asynchronously updated B+-tree. For phantom
avoidance, Griffin validates Inserted and Deleted keys and Scanned key ranges,
according to precision locking [9].

This section proposes a fast index architecture called Griffin. Griffin
consists of two index structures: a hash table for point operations and a
B+tree for Scans connected via precision locking. The hash table and B+-tree
are integrated with precision locking to eliminate phantoms at a low
performance cost (last column of Table III). Griffin offers high performance
for diverse workloads and guarantees phantom avoidance.

###  III-A Overview

The notable features of Griffin, whose structure is illustrated in Fig. 2, are
two-fold. Firstly, to achieve fast point operations (Lookup, Insert, Delete),
the hash table provides $O(1)$ access paths. The hash table is paired with a
B+-tree, which processes Scans in $O(\log N)$, as in conventional B+-tree
indexes.

Secondly, for phantom avoidance, Griffin adopts precision locking (Sec.
II-C2). To provide the mutual exclusion in precision locking, operations that
can cause phantoms (Insert, Delete, Scan) first go through a conflict check;
they search for any conflicting operations being executed. If any conflict is
found, the operation and the transaction that issued it is aborted. Only when
no conflicts are found do they proceed to access the hash table or the
B+-tree. Lookups can directly access the hash table without searching for
conflicts because they do not cause phantoms.

The process each operation goes through is as follows. The conflict check in
Inserts, Deletes, Scans are illustrated in Fig. 3.

  * •

Lookups only access the hash table, which makes it faster than those on a
B+-tree index. This process does not involve access to $L_{u}$ or $L_{p}$.

  * •

An Insert or Delete first adds its entry to $L_{u}$, and checks for conflicts
with $L_{p}$ entries: if the inserted or deleted key does not overlap with any
range stored in $L_{p}$, it proceeds to update the hash table. Otherwise, it
is aborted.

  * •

A Scan first adds its entry to $L_{p}$, and checks for conflicts with $L_{u}$
entries: if the scan range does not overlap with any key stored in $L_{u}$, it
proceeds to access the range index. Otherwise, it is aborted. Note that
rescanning at commit time is not necessary for phantom avoidance, which makes
it faster than a B+-tree index.

Since Inserts and Deletes update the hash table, the hash table is always up-
to-date. However, they do not directly update the B+-tree. To prevent the
B+-tree from growing stale, Griffin performs a periodic synchronization where
Inserts and Deletes to the hash table are applied to the B+-tree in batches.

###  III-B Guarantee of Correctness

Figure 3: Precision locking design. Each $L_{u}$ entry has an Inserted or
Deleted key, along with the status of the transaction that issued it (used by
sync manager, as will be explained in Sec. III-D). Each $L_{p}$ entry has a
Scanned key range and the transaction status.

(a) Catching a phantom.

(b) Catching linearizability violation.

Figure 4: Example cases of transaction aborts in Griffin. Horizontal axis
represents elapsed time. Each box in $L_{u}$ or $L_{p}$ denotes the existence
of a precision locking entry.

In Sect. II-B, we described that the two correctness guarantees that indexes
should provide are phantom avoidance and linearizability. Of these two,
phantom avoidance is avoided by forming the mutual exclusion according to
precision locking. Griffin leverages precision locking not only for phantom
avoidance but also for linearizability.

If Scans were executed without any restriction, the existence of two index
structures could cause stale reads (i.e., linearizability violation). Since
the synchronization of the hash table and B+-tree is periodic, Scans would
miss some recent updates that have been applied only to the hash table but not
to the B+-tree.

This situation is prevented by the precision locking scheme. On performing a
Scan, whenever there is a preceding Insert or Delete that has not been applied
to the B+-tree (a potential stale read situation), Scan will detect its
corresponding entry in $L_{u}$ and abort itself. The synchronization and lock
releasing (garbage collection) algorithm to be explained in Sec. III-D ensures
that any $L_{u}$ entry will not be removed until the corresponding Insert or
Delete is applied to the B+-tree.

###  III-C Behavior Examples

Fig. 4 shows two example cases of transaction aborts in Griffin. Both cases
show that some Insert and Scan operations are in conflict. Cases (a) and (b)
are examples of the detection of a phantom and linearizability violation,
respectively.

In case (a), transaction $t_{1}$ performs two Scans and transaction $t_{2}$
performs an Insert. (1) $t_{1}$ performs the first Scan, adding an entry to
$L_{p}$. (2) $t_{2}$ tries to execute an Insert to x, but gets aborted because
it finds that the entry ‘‘a’’ - ‘‘z’’ overlaps with x. (3) $t_{1}$ performs
the second Scan. A phantom occurs if the two Scans and the insert were all
successful, because the second Scan (2) would observe the existence of x,
while the first Scan of the same transaction (1) would not.

Case (b) depicts a scenario where a conflicting Scan is executed after an
Insert. Here, (1) transaction $t_{1}$ executes an Insert, and after its
completion, (2) transaction $t_{2}$ executes a Scan that overlaps with the
previous Insert. Recall that Inserts and Deletes are initially applied only to
the hash table. Therefore, if the Scan succeeded, it would not see x Inserted
by $t_{1}$, even though the Insert had completed at the start of the Scan.
This is a stale read (linearizability violation) and is prevented by aborting
the Scan in the validation against $L_{u}$.

###  III-D Sync Manager

The inconsistency between the hash table and B+-tree is resolved by a
dedicated thread, sync manager. This inconsistency resolution task consists of
two parts: identifying the difference between the two structures, and bringing
the B+-tree up-to-date.

The difference between the two structures is identified by finding all Inserts
and Deletes created by committed transactions that have not been applied to
the B+-tree. Since Insert and Delete keys are managed by $L_{u}$, each $L_{u}$
entry is labeled with the execution status of the transaction that created it.
When an $L_{u}$ entry is created at the start of an Insert or Delete, it is
labeled as active, and then as committed or aborted when the transaction that
created it terminates. For the entries to be notified of the transaction
termination, we add Commit and Abort to the operation set (Tab. I), which
update the statuses of the entries the transaction has created.

To bring the B+-tree up-to-date, sync manager periodically traverses $L_{u}$
and finds all $L_{u}$ entries with a committed status and applies the
corresponding inserts and deletes on the B+-tree. To avoid applying the same
insert or delete more than once, an $L_{u}$ entry is removed once it has been
applied to the B+-tree. Note that $L_{p}$ is not involved, because it only
holds information of read-only operations.

###  III-E Garbage Collection

Sync manager has another task of garbage collection, i.e., removing precision
locking entries (”releasing” of the locks) that no longer potentially cause
phantoms or stale reads. Garbage collection is necessary for optimal
performance because retaining $L_{u}$ and $L_{p}$ entries long beyond
necessity can cause unnecessary aborts, or cause these lists to grow,
potentially slowing down conflict detection. Two correctness requirements
govern the deletion of precision locking entries:

  1. 1.

For phantom avoidance, an $L_{u}$ or $L_{p}$ entry must be deleted only if the
transaction that created the entry has terminated (committed or aborted).

  2. 2.

For linearizability, an $L_{u}$ entry created by a committed transaction must
be deleted only if the Insert or Delete operation that created it has been
applied to the B+-tree.

To meet 1), Griffin also labels $L_{p}$ entries with transaction execution
statuses as it does for $L_{u}$. Sync manager periodically traverses $L_{p}$,
as well as $L_{u}$, and removes entries with a committed or aborted status. To
meet 2), for $L_{u}$, garbage collection needs to work in concert with
synchronization: before deleting an $L_{u}$ entry with a committed status,
sync manager must complete applying it to the B+-tree,

###  III-F Sync Manager Algorithm

Alg. 1 shows an algorithm of sync manager that performs the synchronization of
the hash table and the range index while garbage collecting entries. Sync
manager periodically inspects $L_{u}$ and $L_{p}$ to find entries issued by
terminated (with a status committed or aborted) transactions. If an $L_{u}$
entry is committed, sync manager applies the insert or delete to the B+-tree
and then deletes the entry. Inserts and Deletes on the hash table issued by
aborted transactions are rolled back, because they are prematurely made
changes.

1

2

3

4Function  _Sync_Manager(__)_ :

5 while  __ do

6

7 foreach  _entry in $L_{u}$ _ do

8 if  _entry has status “committed”_ then

9 B+tree.apply(entry);

10 delete entry;

11

12 if  _entry has status “aborted”_ then

hash_table.rollback(entry);// 333In ”rollback”, we delete or insert the entry
from the hash table if it is an insert or delete event, respectively.

13 delete entry;

14

15 foreach  _entry in $L_{p}$ _ do

16 if  _entry has status “committed” or “aborted”_ then

17 delete entry;

18

Algorithm 1 Sync manager algorithm.

###  III-G Griffin Algorithm

1

2

3Function  _Lookup(_key_)_:

4 return hash_table.get(key)

5

6Function  _InsertOrDelete(_key, value, type:{“insert” or “delete”}_)_:

7 entry = $L_{u}$.add(key, type, “active”);

8 entries.add(entry);

9 if  _key is in some range in $L_{p}$_ then

10 return _abort_

11

12 if  _type is “insert”_ then

13 hash_table.insert(key, value);

14

15 else

16 hash_table.delete(key);

17

18Function  _Scan(_begin, end_)_:

19 entry = $L_{p}$.add(begin, end, “active”);

20 entries.add(entry);

21 if  _some key in $L_{u}$ is in begin-end_ then

22 return _abort_

23

24 B+tree.scan(begin, end);

25

26Function  _Commit(__)_ :

27 foreach  _entry in entries_ do

28 entry.mark(“commit”);

29Function  _Abort(__)_ :

30 foreach  _entry in entries_ do

31 entry.mark(“aborted”);

Algorithm 2 Griffin algorithm. entries is a per-transaction variable that
stores the set of $L_{u}$ and $L_{p}$ entries the transaction has created.

Alg. 2 shows the algorithm of Griffin, which covers all operations shown in
Tab. I. Lookup is the simplest and most efficient operation, accomplished by
only accessing the hash table. An Insert or Delete first adds a lock entry to
$L_{u}$ and then validates against $L_{p}$ to avoid phantoms. Once the
validation has been successful, it performs the actual changes on the hash
table. A Scan adds a lock entry to $L_{p}$ and validates against $L_{u}$ to
preclude phantoms and non-linearizable reads. After a successful validation,
it accesses the B+-tree. Griffin keeps a per-transaction variable entries,
which stores the set of $L_{u}$ and $L_{p}$ entries the transaction has
created, so that the transaction can identify which entries to mark commited
or aborted when Commit or Abort is invoked.

##  IV Implementation

We build a Griffin index to compare its performance with a baseline
architecture. As the baseline, we adopt a B+-Tree architecture that avoids
phantoms by commit-time rescanning, as done by modern in-memory database
systems [10] [11]. For both the baseline and Griffin, we use Bw-Tree [16], a
modern concurrent B+-tree.

B+-tree. As a Bw-Tree implementation, we use OpenBwTree, whose source code is
available online [29]. Griffin uses a hash table to process point operations
and a Bw-tree to process range operations. In Griffin, Bw-tree does not store
data values, only keys, while the hash table stores values or pointers to the
values. Therefore, when a Scan needs to access not only keys but also data
values, it uses the obtained keys to execute Lookup on the hash table.

Hash Table. Griffin has a hash table that optimizes the performance of point
operations. We implement a lock-free hash table in C++ that uses open
addressing and linear probing [14]. It is an array of pointers to data
elements, which is updated by atomic CPU instructions. It handles point
operations (Lookup, Insert, and Delete operations). The amortized calculation
cost of this hash table is $O(1)$, making it efficient for point operations.

Precision Locking. We implement $L_{u}$ and $L_{p}$ as lock-free singly linked
lists [30], each with a tail pointer. When an Insert, Delete, or Scan adds an
entry (Alg. 2 Lines 4, 13), it creates a new entry and redirects the tail
pointer to it with a compare-and-swap instruction. When an Insert or Delete
searches $L_{p}$ for conflicts (and when a Scan searches for $L_{u}$) (Alg. 2
Lines 6 and 15), it traverses the entire list, starting from the tail.

Sync Manager. The sync manager (Alg. 1) periodically performs replication of
the latest entries from the hash table to the B+-tree. It first traverses
$L_{u}$ from the tail, and if it finds an entry with ”committed,” it does
replication. Entries with ”committed” or ”aborted” are eliminated by the
garbage collection module. Subsequently, it traverses $L_{p}$ and does only
garbage collection since entries in $L_{p}$ are only Scan, and they do not
need to be replicated.

Since the sync manager algorithm does not depend on either the data structures
of the hash table or B+-tree, not a single line of code was modified for Bw-
tree.

##  V Evaluation

###  V-A Setup

Workloads. We design workloads based on YCSB benchmark[31]. We populate the
index with 100K keys, each of which is a randomly generated 5-byte string. We
run the following workloads:

  * •

YCSB-A: This workload contains 100% Lookups. The original YCSB-A consists of
50% record reads and 50% record in-place updates. In this experiment, however,
the index is oblivious to the processing on record content and makes no
distinction between them.

  * •

YCSB-E: This workload contains 95% Scans and 5% Inserts. We show a variant of
this workload with varying the length of Scan.

  * •

Scan-only: This workload contains 100% Scans.

  * •

Insert-only: This workload contains 100% Inserts.

For Inserts and Lookups, keys are selected with a uniform distribution. For
Scans, the start key is selected with a uniform distribution, and the size of
the key range is randomly selected (up to 25% of the entire key space). Each
Scan stops after reading 100 keys444In B+-tree, the rescan at commit time is
done by setting the end key of the read predicate as the last key read in the
first scan.. Note that YCSB-E is the only workload where phantom anomaly can
occur, since it is the only mixture of Inserts and Scans.

Running Environment. We evaluate the performance of B+-tree and Griffin by
building and running them on a server machine with the configuration shown in
Tab. IV. We build Griffin, the rescanning logic of B+-tree, and the benchmark
logic in C++. We implement the benchmarks based on the codebase of LineairDB
[32], an open-source transactional key-value store. Index operations and the
benchmark logic are executed in a single process. We instantiate an index for
both B+-tree and Griffin, allowing multiple threads to access it. Each thread
executes operations (e.g., Scan, Lookup) as determined by the workloads. We do
not build concurrency control mechanisms on top of the index, i.e., we only
measure its performance where only the phantom anomaly is avoided. We simulate
short, single-operation transactions; each operation is followed by a Commit
if the operation succeeds or an Abort if it does not. Each data point in the
graphs is derived from an average of three separate runs, with error bars
representing the standard deviation.

TABLE IV: Running Environment. CPU | Intel Xeon E7-8870 v3 CPU * 4 (72 cores)
---|---
L3 Cache | 45MB for each socket
DRAM | 1.5TB
OS | Ubuntu 20.04
Compiler | Clang 10.0.0 (built with -O3 option)

###  V-B YCSB-A Result

Fig. 5 shows the throughput (committed operations per second) versus the
number of threads. Our method (Griffin) shows high scalability and is 3.1x
faster than the baseline (B+-tree) at 64 threads. The improved performance can
be attributed to the use of the hash table for handling point operations
(Lookup), resulting in an amortized $O(1)$ complexity, as opposed to the
$O(\log N)$ complexity of the baseline method, which involves a tree
traversal. Please note that Griffin does not access either precision locking
or B+tree during Lookup. Only the hash table completes the processing.

Figure 5: YCSB-A throughput. Figure 6: YCSB-E throughput.

Figure 7: YCSB-E throughput under variable pause durations. Y-axis is
represented on a logarithmic scale.

Figure 8: Abort rates for Fig. 9.

Figure 9: Scan-only throughput.

###  V-C YCSB-E Result

Original Setting. Fig. 6 shows that Griffin demonstrates a 5.4x higher
throughput compared to B+-tree at 16 threads and 1.6x higher throughput at 80
threads. These performance gains can be attributed to two factors. Firstly,
YCSB-E includes Insert operations, which can cause aborts due to phantoms, and
Griffin has a lower cost for aborts thanks to precision locking. B+-tree
always requires twice tree traversals, and it can detect aborts only at the
commit time. On the other hand, Griffin traverses the tree at most once, and
it can detect aborts before the traversal, which is earlier than that of
B+-tree. Secondly, Griffin has better cache efficiency as it updates the tree
structure in a batch every time the sync manager runs, whereas, in the
baseline, the tree is updated in each operation.

Long Scans. In this workload, the abort rate for the baseline was close to 0%.
This is because the second validation scan is performed immediately following
the first scan. As a result, there are minimal conflicting Inserts executed in
between. However, real-world workloads have long scanning transactions [33,
34], whose scan may be followed by additional scans or even joins, resulting
in a large gap between the initial scan and the commit-time validation scan.

To consider such cases, we conduct a workload that simulates long
transactions. The execution threads are paused for a set duration with a sleep
function after each Scan. After the pause, B+-tree performs a second scan for
validation, while Griffin immediately commits. The number of worker threads is
fixed at 72. Fig. 9 displays the performance as the pause duration varies from
1 to 30 milliseconds. As the pause duration increases, the performance of
B+-tree deteriorates due to an increase in the number of conflicting inserts
and resultant aborts. Fig. 9 shows that the abort rate of the experiments in
Fig. 9. B+-tree showed an inoperable abort rate of 30% with longer pause
durations. On the other hand, Griffin is more stable. This is because a Scan
in Griffin adds an lock entry, preventing itself from being aborted regardless
of the pause duration.

Figure 10: Insert-only throughput.

###  V-D Scan-only and Insert-only Result

Scan-only. Fig. 9 shows the results of the scan-only workload. Despite having
the same $O(\log N)$ complexity as B+-tree for a Scan, Griffin exhibits better
performance, which could be attributed to its reduced validation costs (i.e.,
no rescanning) and improved cache efficiency, which also explains its superior
performance in YCSB-E. Griffin’s scan for this workload consists of adding an
entry to $L_{p}$, validating an empty $L_{u}$, and a single scan. In contrast,
B+-tree performs two scans for rescanning. In general, pushback to the lock-
free list (one CAS in the best case) is significantly faster than scan ($N+1$
memory accesses and compare, where $N$ is the number of entries in the range).
This difference is more notable in cases where disk accesses occur after the
index retrieval. However, the performance gains are not as substantial as in
YCSB-E as there are no aborts.

Insert-only. This workload represents a scenario where many new records are
inserted without being read or updated. The cost of Insert to the B+-tree is
$O(\log N)$ for both B+-tree. Griffin’s overhead is $O(1)$ for the hash table
and for the addition to $L_{u}$. Since the distribution is uniform (the skew
parameter is 0), almost no contention occurs for adding a new entry to the
tree, and thus it is efficient. On the other hand, adding entries to $L_{u}$
severely limits efficiency because all the concurrent Inserts collide with the
tail pointer of the same linked list. Thus, B+-tree makes inserts directly to
the tree without any collision. The results of Insert-only are shown in Fig.
10. Griffin outperforms the baseline until reaching saturation around eight
threads. However, with larger thread counts, the baseline exhibits up to
approximately 1.9x better performance at 80 threads. At the higher thread
counts where Griffin underperforms B+-tree, the primary bottleneck is
identified as the entry addition process of $L_{u}$, which involves updates of
atomic CPU variables in a lock-free linked list.

It is known that centralization can be a bottleneck in transaction processing
[35]. By decentralizing the $L_{u}$ currently implemented in the single lock-
free list, or using a batched scheme [36, 37], Griffin would alleviate the
contentions and may outperform the baseline even in this situation. This is
left for future work.

###  V-E Summary

Griffin offered a direct access path to the hash table for point operations,
and it exhibited about 3.1x better performance than B+-tree in Lookups, but
had scalability problems in Inserts. For Scans and the mixture of Scans and
Inserts, Griffin provides an effective phantom avoidance approach, precision
locking, which eliminates rescanning in B+-tree and results in about 5.4x
better performance. We observe that the advantages of Griffin solve the issues
of B+-tree described in Sec. I in 1) improving the performance of Lookups, 3)
increasing the throughput of Scans, which we believe are desirable properties
for a wide range of practical applications.

##  VI Related Work

Phantom avoidance via tree index. To prevent phantoms, various systems add
synchronization mechanisms to their indexes. MySQL [22] and DB2 [23] use next-
key locking, which synchronizes conflicting operations by acquiring locks for
both the target and subsequent records. Hekaton [10, 16] employs rescanning,
where Scan is repeated at commit time. Silo [11] implements a rescanning
method optimized for Masstree[38].

Phantom avoidance via predicate-based approach. Another approach to phantom
avoidance is predicate locking [9, 39], the prior work most relevant to
precision locking. Unlike next-key locking, predicate locking does not rely on
synchronization in indexes. Transactions post predicates as they execute,
which serve as predicate locks in detecting conflicts between transactions and
determining which transactions to block. However, this method has not been
used in practice because detecting conflicts between general predicates is NP-
hard . Precision locking [12] reduces the computational cost by limiting the
operation set to Insert, Delete and Scan, and predicates to ranges. Griffin
uses precision locking as a means of phantom avoidance and ensuring
linearizability.

Index with multiple data structures. HydraList [40] is similar to Griffin in
that it divides the index into multiple data structures. HydraList splits the
index into a search layer with low update frequency and a data layer with
frequent updates, each implemented using a different data structure. A common
aspect of HydraList and Griffin is that it synchronizes the search layer and
data layer asynchronously to ensure consistency. However, HydraList is not
designed for transaction processing and does not propose a way to avoid
phantoms.

ScaleDB [41] also adopts a strategy akin to Griffin: delaying updates to range
indexes, buffering them in hash tables (indexlets), and merging periodically.
The indexlets also accept point operations as the hash table in Griffin does.
The difference between ScaleDB and Griffin lies in the fairness of operations:
ScaleDB prioritizes inserts and deletes than scans, possibly leading to unfair
aborts of scans in some workloads that include long-running transactions [34,
33]. In ScaleDB, inserts or deletes do not get aborted. On the other hand, in
Griffin, an insert or delete gives way to concurrent scans that have posted
their precision lock entries to $L_{p}$ before the insert or delete does to
$L_{u}$. ScaleDB does not have its counterpart of $L_{p}$ in precision
locking.

##  VII Conclusions

We propose Griffin, a hybrid index architecture for transactional databases
that are designed to improve point operation performance and avoid phantoms
with low overhead while providing linearizable operations. Griffin
incorporates two data structures: a hash table that provides $O(1)$ point
operations and a range index that is typically a B+-tree variant. Griffin
avoids phantoms with low overhead by employing precision locking. Griffin
synchronizes the two structures periodically while eliminating linearizability
violations by leveraging precision locking. As a result, Griffin offers a
transparent interface of a single index with phantom avoidance and
linearizable operations, despite its hybrid architecture. We showed
empirically that Griffin, compared to the conventional architecture of a
B+-tree, results in a marked performance improvement: a 3.1x peak throughput
for a point operation dominant workload and 5.4x for a range operation
dominant workload.

Despite these promising results, several avenues for future work remain.
Firstly, under a very update-heavy workload, we observed that $L_{u}$ and
$L_{p}$ could be a major source of contention that could bottleneck the
performance. Exploring more scalable implementations of precision locking
would be beneficial. Secondly, while we adopted a B+-tree to handle Scans,
evaluating the performance characteristics of Griffin with alternative range
index structures would be valuable. Since precision locking is oblivious to
the index data structure, we can easily use any ordered concurrent index
structure, including a skip list [42], LSM-tree [43], etc.

## References

  * [1] J. Chou, K. Wu, and Prabhat, “Fastquery: A parallel indexing system for scientific data,” in 2011 IEEE International Conference on Cluster Computing, pp. 455–464, 2011.
  * [2] J. Kim, H. Abbasi, L. Chacón, C. Docan, S. Klasky, Q. Liu, N. Podhorszki, A. Shoshani, and K. Wu, “Parallel in situ indexing for data-intensive computing,” in 2011 IEEE Symposium on Large Data Analysis and Visualization, pp. 65–72, 2011.
  * [3] S. Niazi, M. Ismail, S. Haridi, J. Dowling, S. Grohsschmiedt, and M. Ronström, “Hopsfs: scaling hierarchical file system metadata using newsql databases,” in Proceedings of the 15th Usenix Conference on File and Storage Technologies, pp. 89–103, 2017.
  * [4] Y. Wang, Y. Wu, C. Li, P. Zheng, B. Cao, Y. Sun, F. Zhou, Y. Xu, Y. Wang, and G. Xie, “Cfs: Scaling metadata service for distributed file system via pruned scope of critical sections,” in Proceedings of the Eighteenth European Conference on Computer Systems, EuroSys ’23, p. 331–346, 2023.
  * [5] O. Tatebe, K. Hiraga, and N. Soda, “Gfarm grid file system,” New Gener. Comput., vol. 28, no. 3, pp. 257–275, 2010.
  * [6] Y. O. Koçberber, B. Grot, J. Picorel, B. Falsafi, K. T. Lim, and P. Ranganathan, “Meet the walkers: accelerating index traversals for in-memory databases,” in MICRO, pp. 468–479, ACM, 2013.
  * [7] dbdb.io, “Database of Databases.” https://dbdb.io/browse.  [Accessed 19-Sep-2022].
  * [8] T. H. Cormen, C. E. Leiserson, R. L. Rivest, and C. Stein, Introduction to Algorithms, 3rd Edition.  MIT Press, 2009.
  * [9] K. P. Eswaran, J. Gray, R. A. Lorie, and I. L. Traiger, “The notions of consistency and predicate locks in a database system,” Commun. ACM, vol. 19, no. 11, pp. 624–633, 1976.
  * [10] P. Larson, S. Blanas, C. Diaconu, C. Freedman, J. M. Patel, and M. Zwilling, “High-performance concurrency control mechanisms for main-memory databases,” Proc. VLDB Endow., 2011.
  * [11] S. Tu, W. Zheng, E. Kohler, B. Liskov, and S. Madden, “Speedy transactions in multicore in-memory databases,” in SOSP, pp. 18–32, 2013.
  * [12] J. R. Jordan, J. Banerjee, and R. B. Batman, “Precision locks,” in SIGMOD Conf., pp. 143–147, 1981.
  * [13] M. Herlihy and J. M. Wing, “Linearizability: A correctness condition for concurrent objects,” ACM Trans. Program. Lang. Syst., vol. 12, no. 3, pp. 463–492, 1990.
  * [14] H. Gao, J. F. Groote, and W. H. Hesselink, “Lock-free dynamic hash tables with open addressing,” Distributed Comput., vol. 18, no. 1, pp. 21–42, 2005\.
  * [15] Z. Wang, A. Pavlo, H. Lim, V. Leis, H. Zhang, M. Kaminsky, and D. G. Andersen, “Building a bw-tree takes more than just buzz words,” in SIGMOD Conf., pp. 473–488, 2018.
  * [16] J. J. Levandoski, D. B. Lomet, and S. Sengupta, “The bw-tree: A b-tree for new hardware platforms,” in ICDE, pp. 302–313, 2013.
  * [17] T. J. Lehman and M. J. Carey, “A study of index structures for main memory database management systems,” in VLDB, p. 294–303, 1986.
  * [18] J. Arulraj, J. J. Levandoski, U. F. Minhas, and P. Larson, “Bztree: A high-performance latch-free range index for non-volatile memory,” PVLDB, vol. 11, no. 5, pp. 553–565, 2018.
  * [19] X. Wu, F. Ni, and S. Jiang, “Wormhole: A fast ordered index for in-memory data management,” in Proceedings of the Fourteenth EuroSys Conference 2019, Dresden, Germany, March 25-28, 2019, pp. 18:1–18:16, ACM, 2019.
  * [20] M. Reimer, “Solving the phantom problem by predicative optimistic concurrency control,” in VLDB, pp. 81–88, 1983.
  * [21] A. Adya, B. Liskov, and P. E. O’Neil, “Generalized isolation level definitions,” in ICDE, pp. 67–78, 2000.
  * [22] MySQL, “MySQL 8.0 Reference Manual :: 15.7.4 Phantom Rows.” https://dev.mysql.com/doc/refman/8.0/en/innodb-next-key-locking.html.  [Accessed 19-Sep-2022].
  * [23] IBM, “Db2 version 10.1 for linux, next-key locking.” https://www.ibm.com/docs/en/db2/10.1.0?topic=management-next-key-locking.  [Accessed 19-Sep-2022].
  * [24] C. Mohan, “ARIES/KVL: A key-value locking method for concurrency control of multiaction transactions operating on b-tree indexes,” in VLDB, pp. 392–405, 1990.
  * [25] J. Guo, P. Cai, J. Wang, W. Qian, and A. Zhou, “Adaptive optimistic concurrency control for heterogeneous workloads,” PVLDB, vol. 12, no. 5, pp. 584–596, 2019.
  * [26] C. Diaconu, C. Freedman, E. Ismert, P. Larson, P. Mittal, R. Stonecipher, N. Verma, and M. Zwilling, “Hekaton: SQL server’s memory-optimized OLTP engine,” in SIGMOD Conf., pp. 1243–1254, 2013.
  * [27] H. T. Kung and J. T. Robinson, “On optimistic methods for concurrency control,” ACM Trans. Database Syst., pp. 213–226, 1981.
  * [28] T. Neumann, T. Mühlbauer, and A. Kemper, “Fast serializable multi-version concurrency control for main-memory database systems,” in SIGMOD Conf., pp. 677–689, 2015.
  * [29] GitHub, “wangziqi2013/BwTree: An open sourced implementation of Bw-Tree in SQL Server Hekaton.” https://github.com/wangziqi2013/BwTree.  [Accessed 19-Sep-2022].
  * [30] J. D. Valois, “Lock-free linked lists using compare-and-swap,” in PODC, pp. 214–222, 1995.
  * [31] B. F. Cooper, A. Silberstein, E. Tam, R. Ramakrishnan, and R. Sears, “Benchmarking cloud serving systems with YCSB,” in SoCC, pp. 143–154, 2010.
  * [32] GitHub, “LineairDB/LineairDB: C++ fast transactional key-value storage.” https://github.com/LineairDB/LineairDB.  [Accessed 19-Sep-2022].
  * [33] J. Chen, Y. Ding, Y. Liu, F. Li, L. Zhang, M. Zhang, K. Wei, L. Cao, D. Zou, Y. Liu, L. Zhang, R. Shi, W. Ding, K. Wu, S. Luo, J. Sun, and Y. Liang, “Bytehtap: bytedance’s htap system with high data freshness and strong data consistency,” Proc. VLDB Endow., vol. 15, p. 3411–3424, aug 2022.
  * [34] J. Nemoto, T. Kambayashi, T. Hoshino, and H. Kawashima, “Oze: Decentralized graph-based concurrency control for real-world long transactions on bom benchmark,” CoRR, vol. abs/2210.04179, 2022.
  * [35] T. Tanabe, T. Hoshino, H. Kawashima, and O. Tatebe, “An analysis of concurrency control protocols for in-memory database with ccbench,” PVLDB, vol. 13, no. 13, pp. 3531–3544, 2020.
  * [36] A. Thomson, T. Diamond, S. Weng, K. Ren, P. Shao, and D. J. Abadi, “Calvin: fast distributed transactions for partitioned database systems,” in SIGMOD Conf. (K. S. Candan, Y. Chen, R. T. Snodgrass, L. Gravano, and A. Fuxman, eds.), pp. 1–12, ACM, 2012.
  * [37] M. Uchida and H. Kawashima, “CLMD: making lock manager predictable and concurrent for deterministic concurrency control,” Int. J. Netw. Comput., vol. 14, no. 1, pp. 81–92, 2024.
  * [38] Y. Mao, E. Kohler, and R. T. Morris, “Cache craftiness for fast multicore key-value storage,” in Eurosys, pp. 183–196, 2012.
  * [39] M. Reimer, “Solving the phantom problem by predicative optimistic concurrency control,” in Proceedings of the 9th International Conference on Very Large Data Bases, VLDB ’83, (San Francisco, CA, USA), p. 81–88, Morgan Kaufmann Publishers Inc., 1983.
  * [40] A. Mathew and C. Min, “Hydralist: A scalable in-memory index using asynchronous updates and partial replication,” PVLDB, vol. 13, no. 9, pp. 1332–1345, 2020.
  * [41] S. A. Mehdi, D. Hwang, S. Peter, and L. Alvisi, “Scaledb: A scalable, asynchronous in-memory database,” in OSDI, pp. 361–376, USENIX Association, 2023.
  * [42] M. Fomitchev and E. Ruppert, “Lock-free linked lists and skip lists,” in PODC 2004, pp. 50–59, 2004.
  * [43] P. E. O’Neil, E. Y. C. Cheng, D. Gawlick, and E. J. O’Neil, “The log-structured merge-tree (lsm-tree),” Acta Informatica, vol. 33, pp. 351–385, 1996.


# Asymptotic properties of neutral type linear systems

Leonid Berezansky  Elena Braverman  Dept. of Math., Ben-Gurion University of
the Negev, Beer-Sheva 84105, Israel  Dept. of Math. and Stats., University of
Calgary, Calgary, AB T2N 1N4, Canada

###### Abstract

Exponential stability and solution estimates are investigated for a delay
system

$\dot{x}(t)-A(t)\dot{x}(g(t))=\sum_{k=1}^{m}B_{k}(t)x(h_{k}(t))$

of a neutral type, where $A$ and $B_{k}$ are $n\times n$ bounded matrix
functions, and $g,h_{k}$ are delayed arguments. Stability tests are applicable
to a wide class of linear neutral systems with time-varying coefficients and
delays. In addition, explicit exponential estimates for solutions of both
homogeneous and non-homogeneous neutral systems are obtained for the first
time. These inequalities are not just asymptotic estimates, they are valid on
every finite segment and evaluate both short- and long-term behaviour of
solutions.

###### keywords:

linear neutral delay system, exponential stability, non-autonomous system,
exponential estimates of solutions, matrix measure AMS subject classification:
34K20, 34K40, 34K25, 34K06

††journal: Journal of Mathematical Analysis and Applications

##  1 Introduction

There are many papers and monographs on stability of scalar neutral
differential equations, see a review of explicit stability tests for this
class of equations in [3, 4]. For linear vector neutral delay equations,
explicit exponential stability results can be found in the monographs [1, 11,
13, 19, 20, 27] and the papers [2, 9, 12, 15, 17, 23, 24, 25, 26].

A most popular approach to study stability for all classes of functional
differential equations, including neutral, is the application of Lyapunov-
Krasovskii functionals [13, 19, 20, 27]. LMI (linear matrix inequality) method
is also based on the method of Lyapunov-Krasovskii functionals [10, 22, 26].
Some stability results were obtained by using the Bohl-Perron theorem [1, 3,
4, 5, 6, 7, 9] and application of special properties of matrices, including
fundamental matrix functions for differential equations [11, 14, 15, 24, 25].
Several tests for linear and nonlinear scalar neutral equations were obtained
by the fixed point method [18, 30]. Stability conditions based on the
application of fixed point theorems usually include the first and the second
derivatives of delay functions. A more detailed discussion of these methods
and comparison of stability results of the present paper to some earlier
obtained is postponed to the end of the paper.

Recently in [4], exponential estimates were derived for a neutral delay
equation

$\dot{x}(t)-a(t)\dot{x}(g(t))=\sum_{k=1}^{m}b_{k}(t)x(h_{k}(t)),~{}~{}t\geq
t_{0}\geq 0$ (1.1)

in the scalar case. In the present paper we extend the results obtained in [4]
to a system

$\dot{x}(t)-A(t)\dot{x}(g(t))=\sum_{k=1}^{m}B_{k}(t)x(h_{k}(t)),~{}~{}t\geq
t_{0}\geq 0,$ (1.2)

where some of the stability tests are new also for scalar equation (1.1) (we
will discuss this question in the last section) and for a vector linear delay
differential equations without the neutral part when $A(t)\equiv 0$.

We study non-autonomous system (1.2) and get stability tests where not only
the maximal of all the delays but each $h_{k}$ is taken into account.

These tests are explicit, we compare them to some earlier results. Our second
goal is to develop exponential estimates for solutions of a non-homogeneous
version of (1.2), with coefficient of the exponential part described by a
maximum of the initial functions, while the maximum of the right-hand side
leads to a constant bound, not an exponential estimate of a solution. We
evaluate short-term, as well as long-term (asymptotic) behaviour of a
solution. To the best of our knowledge, for neutral differential systems such
exponential estimates have not been known, and the present paper fills the
gap.

Equation (1.2) includes equations without the neutral part

$\dot{x}(t)=\sum_{k=1}^{m}B_{k}(t)x(h_{k}(t)),~{}~{}t\geq t_{0}\geq 0,$

an equation with one delay ($m=1$) and autonomous equations.

In the monograph [19], the method of Lyapunov-Krasovskii functionals was
applied to local asymptotic stability for vector nonlinear delay differential
equations. Relevant Theorem 3.1 in [19, p. 286] was actually obtained for
nonlinear equations, and we reformulate it for the linear case

$\dot{x}(t)=B(t)x(t-h),\,\,\,t\geq 0,$ (1.3)

where $B$ is an $n\times n$ matrix with locally essentially bounded entries,
and $h>0$ is a constant delay.

Below, $\|\cdot\|$ is a norm in ${\mathbb{R}}^{n}$, and $\mu(A)$ is a matrix
measure which is defined in the next section.

######  Proposition 1.

Let $t_{0}\geq 0$, $\mu(B(t))\leq-\beta<0$ and $\displaystyle h\,\sup_{t\geq
t_{0}}\|B(t)\|^{2}<\inf_{t\geq t_{0}}\,|\mu(B(t))|$.

Then equation (1.3) is uniformly asymptotically stable.

A significant part of known asymptotic stability tests for neutral equations
was obtained for autonomous systems with a non-delay term, such as

$\dot{x}(t)-A_{1}\dot{x}(t-h_{1})=A_{0}x(t)+A_{2}x(t-h_{2}),~{}h_{1},h_{2}>0,~{}t\geq
t_{0}.$ (1.4)

The following stability tests were obtained using Lyapunov-Krasovskii
functionals.

######  Proposition 2.

[19, P. 367],[23] Let $\|A_{1}\|<1$ and
$\displaystyle\mu(A_{0})+\frac{\|A_{0}\|+\|A_{1}\|\|A_{2}\|}{1-\|A_{1}\|}<0$.

Then system (1.4) is asymptotically stable.

######  Proposition 3.

[19, P. 369] If $\|A_{1}\|+h_{2}\|A_{2}\|<1$ and

$\displaystyle\mu(A_{0}+A_{2})+\frac{\|A_{0}+A_{2}\|(\|A_{1}\|+h_{2}\|A_{2}\|)}{1-\|A_{1}\|-h_{2}\|A_{2}\|}<0$

then system (1.4) is asymptotically stable.

The structure of the paper is the following. Section 2 presents preliminaries,
while main results on solution estimates and exponential stability are
obtained in Section 3. We get solution estimates for system (1.2) or its non-
homogeneous counterpart and derive stability tests for (1.2). Section 4
illustrates novelty of the results with examples and indicates possible
directions of further research. We also discuss Propositions 1-3 and compare
them to the results obtained in the paper in Section 4.

##  2 Preliminaries

There exists a well developed theory of neutral linear differential equations
including existence, uniqueness, representation of solutions, see e.g. [1, 11,
16, 19, 20]. We use some results and definitions from these monographs,
including definitions of asymptotic and uniform exponential stability.

Let $\|x\|$ be an arbitrary vector norm of $x\in{\mathbb{R}}^{n}$, the same
notation is used for the induced matrix norm. The matrix measure (often
referred to as the logarithmic matrix norm) of an $n\times n$ matrix $C$ is
defined as

$\mu(C)=\left.\left.\lim_{\nu\to 0^{+}}{\nu}^{-1}\right(\,{\|E+\nu
C\|-1\,}\right),$

where $E$ is the $n\times n$ identity matrix. Some of its properties are
useful in calculations:

$|\mu(C)|\leq\|C\|,~{}~{}\mu(C_{1}+C_{2})\leq\mu(C_{1})+\mu(C_{2}),~{}~{}\mu(\lambda
C)=\lambda\mu(C),~{}\lambda>0.$

For details, we refer readers to [28, 29] and [19, Table 3.1, p. 286].

In particular, if we use the maximum norm
$\|x\|_{\infty}=\max\\{|x_{1}|,\dots,|x_{n}|\\}$ then

$\|C\|=\max_{1\leq i\leq
n}\left\\{\sum_{j=1}^{n}|c_{ij}|\right\\},~{}~{}\mu(C)=\max_{1\leq i\leq
n}\left\\{c_{ii}+\sum_{j\neq i}|c_{ij}|\right\\}.$

For either a fixed interval $J=[t_{0},t_{1}]$ or $J=[t_{0},\infty)$, consider
the space $L_{\infty}(J)$ with an essential supremum norm
$\|x\|_{J}=\operatorname*{ess\,sup}_{t\in J}\|x(t)\|$. Further, by $\sup$ of
any Lebesgue measurable function we mean an essential supremum without
mentioning it.

For system (1.2), the functions $A,B_{k},g,h_{k}$ are assumed to be Lebesgue
measurable on $[t_{0},\infty)$, where $t_{0}\geq 0$ is an arbitrary initial
point, $n\times n$ matrix functions $A$ and $B_{k}$ are essentially bounded on
$[t_{0},\infty)$, delays in $g$ and $h_{k}$ are bounded: $0\leq
t-g(t)\leq\sigma$, $0\leq t-h_{k}(t)\leq\tau_{k}$ for $\sigma>0$,
$\tau_{k}>0$, $k=1,\dots,m$. The coefficient $A$ satisfies $\|A(t)\|\leq
a_{0}<1$ for some $a_{0}<1$ for $t\geq t_{0}$.

The condition on the neutral delay that, once the Lebesgue measure of the set
$U$ is zero, the set $g^{-1}(U)$ has also the zero measure, ensures that
$x(g(t))$ is properly defined and measurable, once $x$ is measurable.

In addition to (1.2), we introduce a system

$\dot{x}(t)-A(t)\dot{x}(g(t))=\sum_{k=1}^{m}B_{k}(t)x(h_{k}(t))+f(t),~{}t\geq
t_{0}$ (2.1)

with initial conditions

$x(t)=\Phi(t)\mbox{~{}for~{}~{}}t\leq
t_{0},\quad\dot{x}(t)=\Psi(t)\mbox{~{}for~{}~{}}t<t_{0}.$ (2.2)

Here $f\in L_{\infty}([t_{0},c])$ for any $c>t_{0}$, while
$\Phi:[t_{0}-\max_{k}\tau_{k},t_{0}]\rightarrow{\mathbb{R}}^{n}$ and
$\Psi:[t_{0}-\sigma,t_{0})\rightarrow{\mathbb{R}}^{n}$, in addition to
boundedness, are supposed to be Borel measurable.

Everywhere below we let these assumptions be satisfied, for example,
considering (2.1),(2.2) or any delay system, without repeating them.

By a solution of problem (2.1),(2.2) we mean a locally absolutely continuous
on $[t_{0},\infty)$ function $x:{\mathbb{R}}\rightarrow{\mathbb{R}}^{n}$
satisfying system (2.1) for almost all $t\in[t_{0},\infty)$ and initial
conditions (2.2) when $t\leq t_{0}$.

The above conditions on the parameters of the equations and initial conditions
guarantee existence and uniqueness of a solution of initial value problem
(2.1),(2.2) [1], and a solution representation which will later be applied.

For each $s\geq t_{0}$ we introduce the fundamental matrix as a solution
$X(t,s)$ of

$\dot{x}(t)-A(t)\dot{x}(g(t))=\sum_{k=1}^{m}B_{k}(t)x(h_{k}(t)),~{}x(t)=0,~{}\dot{x}(t)=0,~{}t<s,~{}x(s)=E,$

where $E$ is the identity matrix. By definition, $X(t,s)$ vanishes whenever
$t<s$.

If there exist positive numbers $M$ and $\gamma$ for which any solution of
(1.2),(2.2) satisfies

$\|x(t)\|\leq Me^{-\gamma(t-t_{0})}\left[\sup_{t\in[t_{0}-\max_{1\leq k\leq
m}\tau_{k},t_{0}]}\|\Phi(t)\|+\sup_{t\in[t_{0}-\sigma,t_{0}]}\|\Psi(t)\|\right],~{}~{}t\geq
t_{0},$

where neither $M$ nor $\gamma$ depends on $t_{0}\geq 0$ and the initial
functions $\Phi$ and $\Psi$, system (1.2) is called uniformly exponentially
stable. Also, exponential estimates of a fundamental matrix $X(t,s)$ will be
considered $\displaystyle\|X(t,s)\|\leq M_{0}e^{-\gamma_{0}(t-s)}$ for $t\geq
s\geq t_{0}$ and some $M_{0}>0$ and $\gamma_{0}>0$ which hold with $M_{0}=M$,
$\gamma_{0}=\gamma$ if (1.2) is uniformly exponentially stable.

Define a linear bounded operator on the space $L_{\infty}[t_{0},t_{1}]$ as

$\displaystyle(Sy)(t)=\left\\{\begin{array}[]{ll}A(t)y(g(t)),&g(t)\geq
t_{0},\\\ 0,&g(t)<t_{0}.\\\ \end{array}\right.$

Note that there exists a unique solution (see, for example, [1]) of problem
(2.1),(2.2). This solution has the representation

$\begin{array}[]{ll}\displaystyle x(t)=&\displaystyle
X(t,t_{0})x_{0}+\\!\\!\int\limits_{t_{0}}^{t}\\!\\!X(t,s)\left[(I-S)^{-1}f\right](s)ds\\\
&\displaystyle+\\!\\!\int\limits_{t_{0}}^{t_{0}+\sigma}\\!\\!\\!\\!X(t,s)\left[(I-S)^{-1}(A(\cdot)\Psi(g(\cdot)))\right](s)ds\\\
&\displaystyle+\sum_{k=1}^{m}\int\limits_{t_{0}}^{t_{0}+\tau_{k}}X(t,s)\left[(I-S)^{-1}(B_{k}(\cdot)\Phi(h_{k}(\cdot)))\right](s)ds,\end{array}$
(2.3)

where $I:L_{\infty}(J)\to L_{\infty}(J)$ is the identity operator, and we set
$\Psi(g(t))=0$ for $g(t)\geq t_{0}$ and $\Phi(h_{k}(t))=0$ whenever
$h_{k}(t)\geq t_{0}$. For any $t_{1}>t_{0}$, the norm of $(I-S)^{-1}$
satisfies [1]

$\|(I-S)^{-1}\|_{L_{\infty}[t_{0},t_{1}]\to
L_{\infty}[t_{0},t_{1}]}\leq\frac{1}{1-\|A\|_{[t_{0},\infty)}}\,.$ (2.4)

We use an auxiliary system with a term not involving any delay

$\dot{z}(t)-A_{0}(t)\dot{z}(g(t))=C(t)z(t)+\sum_{k=0}^{m}D_{k}(t)z(h_{k}(t)),~{}t\geq
t_{0}.$ (2.5)

First, let us evaluate the fundamental matrix of system (2.5). Denote

$D(t):=\sum_{k=0}^{m}D_{k}(t).$ (2.6)

######  Lemma 1.

Let $\|A_{0}\|_{[t_{0},\infty)}<1$, there exist an $\alpha_{0}<0$ such that
$\mu(C(t)+D(t))\leq\alpha_{0}$, $Z$ be a fundamental matrix of system (2.5),
and

$K_{0}:=\frac{\|C\|_{[t_{0},\infty)}+\sum_{k=0}^{m}\|D_{k}\|_{[t_{0},\infty)}}{1-\|A_{0}\|_{[t_{0},\infty)}}\left(\left\|\frac{A_{0}}{\mu(C+D)}\right\|_{[t_{0},\infty)}+\sum_{k=0}^{m}\tau_{k}\left\|\frac{D_{k}}{\mu(C+D)}\right\|_{[t_{0},\infty)}\right)<1.$
(2.7)

Then, $Z(t,s)$ satisfies

$\|Z(t,s)\|\leq K,~{}~{}t\geq s\geq t_{0},$ (2.8)

where the bound $K$ is $K=(1-K_{0})^{-1}$.

###### Proof.

We denote $z(t)=Z(t,t_{0})$ to make expressions shorter. By definition, $z$
satisfies (2.5), where the initial matrix is $z(t_{0})=E$, and the initial
functions are identically equal to the zero matrix. For an arbitrary
$t_{1}>t_{0}$, denote $J=[t_{0},t_{1}]$. By (2.4) and (2.5), we get the
inequality

$\|\dot{z}\|_{J}\leq\frac{\|C\|_{[t_{0},\infty)}+\sum_{k=0}^{m}\|D_{k}\|_{[t_{0},\infty)}}{1-\|A_{0}\|_{[t_{0},\infty)}}\|z\|_{J}.$
(2.9)

A fundamental matrix $Y(t,s)$ of the ordinary differential equation

$\dot{y}(t)=(C(t)+D(t))y(t)$

has an exponential estimate [8, Page 9]

$\|Y(t,s)\|\leq e^{\int_{s}^{t}\mu(C(\xi)+D(\xi))d\xi}.$ (2.10)

Further, we rewrite (2.5) with a different non-delay term

$\dot{z}(t)=[C(t)+D(t)]z(t)+A_{0}(t)\dot{z}(g(t))-\sum_{k=0}^{m}D_{k}(t)\int_{h_{k}(t)}^{t}\dot{z}(\xi)d\xi.$
(2.11)

Integrating from $t_{0}$ to $t\leq t_{1}$, we get:

$\begin{array}[]{ll}z(t)=&\displaystyle
Y(t,t_{0})+\int_{t_{0}}^{t}Y(t,s)\mu(C(s)+D(s))\left[\frac{A_{0}(s)}{\mu(C(s)+D(s))}\dot{z}(g(s))\right.\\\
&\left.\displaystyle-\sum_{k=0}^{m}\frac{D_{k}(s)}{\mu(C(s)+D(s))}\int_{h_{k}(s)}^{s}\dot{z}(\xi)d\xi\right]ds.\end{array}$

Therefore, using (2.9),(2.10), inequality $\mu(C(t)+D(t))\leq\alpha_{0}<0$
leads to

$\left\|\int_{t_{0}}^{t}Y(t,s)\mu(C(s)+D(s))~{}ds\right\|\leq 1$

and also recalling $K_{0}$ from (2.7),

$\|z\|_{J}\leq
1+\left(\left\|\frac{A_{0}}{\mu(C+D)}\right\|_{[t_{0},\infty)}+\sum_{k=0}^{m}\tau_{k}\left\|\frac{D_{k}}{\mu(C+D)}\right\|_{[t_{0},\infty)}\right)\|\dot{z}\|_{J}\leq
1+K_{0}\|z\|_{J}.$

We get $\|Z(t,t_{0})\|_{[t_{0},t_{1}]}\leq(1-K_{0})^{-1}$, and the expression
in the right-hand side does not depend on $t_{1}$, which implies
$\displaystyle\|Z(t,t_{0})\|_{[t_{0},\infty)}\leq(1-K_{0})^{-1}$. This
inequality is also valid if $t_{0}$ is replaced with $s>t_{0}$. Hence estimate
(2.8) is valid, which concludes the proof. ∎

######  Lemma 2.

Let
$\displaystyle\|A_{0}\|_{[t_{0},\infty)}+\sum_{k=0}^{m}\tau_{k}\|D_{k}\|_{[t_{0},\infty)}<1$,
$\mu(C(t)+D(t))\leq\alpha_{0}$ for some $\alpha_{0}<0$, where $D$ from (2.6)
is used, $Z$ be a fundamental matrix of (2.5), and the constant

$\displaystyle
L_{0}:=\displaystyle\frac{\|C+D\|_{[t_{0},\infty)}}{1-\|A_{0}\|_{[t_{0},\infty)}-\sum_{k=0}^{m}\tau_{k}\|D_{k}\|_{[t_{0},\infty)}}\displaystyle\left(\left\|\frac{A_{0}}{\mu(C+D)}\right\|_{[t_{0},\infty)}+\sum_{k=0}^{m}\tau_{k}\left\|\frac{D_{k}}{\mu(C+D)}\right\|_{[t_{0},\infty)}\right)<1.$

Then, $Z(t,s)$ satisfies (2.8), where $L=(1-L_{0})^{-1}$ is used instead of
$K$.

###### Proof.

Again, $z(t)=Z(t,t_{0})$ satisfies (2.5) with the zero initial matrix-
functions and $z(t_{0})=E$. Let $J=[t_{0},t_{1}]$ for any $t_{1}>t_{0}$.
Equality (2.11) implies

$\|\dot{z}\|_{J}\leq\|C+D\|_{[t_{0},\infty)}\|z\|_{J}+\left(\|A_{0}\|_{[t_{0},\infty)}+\sum_{k=0}^{m}\tau_{k}\|D_{k}\|_{[t_{0},\infty)}\right)\|\dot{z}\|_{J},$

therefore

$\|\dot{z}\|_{J}\leq\frac{\|C+D\|_{[t_{0},\infty)}}{1-\|A_{0}\|_{[t_{0},\infty)}-\sum_{k=0}^{m}\tau_{k}\|D_{k}\|_{[t_{0},\infty)}}\|z\|_{J}.$

The rest of the proof repeats the scheme for Lemma 1 and thus is omitted. ∎

##  3 Main Results

###  3.1 Boundedness and solution estimates

For any $\lambda\in{\mathbb{R}}$, denote the matrix function

$P(t):=\sum_{k=1}^{m}e^{\lambda(t-h_{k}(t))}B_{k}(t)-\lambda
e^{\lambda(t-g(t))}A(t)+\lambda E.$ (3.1)

We will show that, once the matrix measure of $P(t)$ in (3.1) is less than a
constant negative number, for a positive $\lambda$ and under some other
natural assumptions, (1.2) is globally exponentially stable, and a solution
estimate can be derived.

######  Theorem 1.

Let $\lambda$ and $\beta$ be positive constants for which

$\mu(P(t))\leq-\beta,\quad t\geq t_{0},\quad
e^{\lambda\sigma}\|A\|_{[t_{0},\infty)}<1,$ (3.2)
$\begin{array}[]{ll}M_{1}:=&\displaystyle\frac{\lambda+\sum\limits_{k=1}^{m}e^{\lambda\tau_{k}}\|B_{k}\|_{[t_{0},\infty)}+\lambda
e^{\lambda\sigma}\|A\|_{[t_{0},\infty)}}{1-e^{\lambda\sigma}\|A\|_{[t_{0},\infty)}}\vspace{2mm}\\\
&\displaystyle\times\left(\left\|\frac{A}{\mu(P)}\right\|_{[t_{0},\infty)}\\!\\!\\!\\!\\!\\!\\!\\!\\!\\!(1+\lambda\sigma)e^{\lambda\sigma}+\sum_{k=1}^{m}\left\|\frac{B_{k}}{\mu(P)}\right\|_{[t_{0},\infty)}\\!\\!\\!\\!\\!\\!\\!\\!\\!\\!e^{\lambda\tau_{k}}\tau_{k}\right)<1,\end{array}$
(3.3)

where $P$ is defined in (3.1). Then, for $M_{0}:=(1-M_{1})^{-1}$, the solution
of (2.1),(2.2) satisfies

$\begin{array}[]{ll}\|x(t)\|\leq&\displaystyle
M_{0}e^{-\lambda(t-t_{0})}\left[\|x(t_{0})\|+\frac{e^{\lambda\sigma}-1}{\lambda(1-\|A\|_{[t_{0},\infty)})}\|A\|_{[t_{0},\infty)}\|\Psi\|_{[t_{0}-\sigma,t_{0}]}\right.\vspace{2mm}\\\
&\displaystyle\left.+\sum_{k=1}^{m}\frac{e^{\lambda\tau_{k}}-1}{\lambda(1-\|A\|_{[t_{0},\infty)})}\|B_{k}\|_{[t_{0},\infty)}\|\Phi\|_{[t_{0}-\tau_{k},t_{0}]}\right]+\frac{M_{0}}{\lambda(1-\|A\|_{[t_{0},\infty)})}\|f\|_{[t_{0},t]}.\end{array}$
(3.4)

###### Proof.

We start with homogeneous system (1.2). Substituting
$x(t)=e^{-\lambda(t-t_{0})}y(t)$ into (1.2), we obtain

$\dot{y}(t)-A(t)e^{\lambda(t-g(t))}\dot{y}(g(t))=\lambda y(t)-\lambda
e^{\lambda(t-g(t))}A(t)y(g(t))+\sum_{k=1}^{m}e^{\lambda(t-h_{k}(t))}B_{k}(t)y(h_{k}(t)).$
(3.5)

Equation (3.5) has the form of (2.5) with

$A_{0}(t)=e^{\lambda(t-g(t))}A(t),~{}~{}C(t)=\lambda E,~{}~{}D_{0}(t)=-\lambda
e^{\lambda(t-g(t))}A(t),~{}~{}h_{0}(t)=g(t),$
$D_{k}(t)=e^{\lambda(t-h_{k}(t))}B_{k}(t),~{}k=1,\dots,m,~{}~{}D(t)=\sum_{k=0}^{m}D_{k}(t).$

Therefore $P(t)=C(t)+D(t)$,

$\left\|\frac{A_{0}}{\mu(C+D)}\right\|_{[t_{0},\infty)}\leq
e^{\lambda\sigma}\left\|\frac{A}{\mu(P)}\right\|_{[t_{0},\infty)},\left\|\frac{D_{0}}{\mu(C+D)}\right\|_{[t_{0},\infty)}\leq\lambda
e^{\lambda\sigma}\left\|\frac{A}{\mu(P)}\right\|_{[t_{0},\infty)},$
$\left\|\frac{D_{k}}{\mu(C+D)}\right\|_{[t_{0},\infty)}\leq
e^{\lambda\tau_{k}}\left\|\frac{B_{k}}{\mu(P)}\right\|_{[t_{0},\infty)},k=1,\dots,m,$
$\frac{\|C\|_{[t_{0},\infty)}+\sum_{k=0}^{m}\|D_{k}\|_{[t_{0},\infty)}}{1-\|A_{0}\|_{[t_{0},\infty)}}\leq\frac{\lambda+\sum_{k=1}^{m}e^{\lambda\tau_{k}}\|B_{k}\|_{[t_{0},\infty)}+\lambda
e^{\lambda\sigma}\|A\|_{[t_{0},\infty)}}{1-e^{\lambda\sigma}\|A\|_{[t_{0},\infty)}}.$

Inequalities (3.2) and (3.3) imply the assumptions of Lemma 1, in particular,
(2.7). Let $Y(t,s)$ be a fundamental matrix of (3.5), then we can apply Lemma
1 to deduce $\|Y(t,s)\|\leq M_{0}$. Once $X(t,s)$ is a fundamental matrix of
system (1.2), it satisfies $X(t,s)=e^{-\lambda(t-s)}Y(t,s)$. This implies the
exponential estimate $\|X(t,s)\|\leq M_{0}e^{-\lambda(t-s)}$. Let $x$ be a
solution of problem (1.2),(2.2). We use solution representation (2.3) and
inequality (2.4)

$\displaystyle\|x(t)\|\leq$
$\displaystyle\|X(t,t_{0})\|\|x_{0}\|+\left.\left.\int_{t_{0}}^{t_{0}+\sigma}\|X(t,s)\|\right\|(I-S)^{-1}\right\|_{L_{\infty}[t_{0},t_{1}]\to
L_{\infty}[t_{0},t_{1}]}\|A(s)\|\|\Psi(g(s))\|ds$
$\displaystyle+\sum_{k=1}^{m}\left.\left.\int_{t_{0}}^{t_{0}+\tau_{k}}\|X(t,s)\|\right\|(I-S)^{-1}\right\|_{L_{\infty}[t_{0},t_{1}]\to
L_{\infty}[t_{0},t_{1}]}\|B_{k}(s)\|\|\Phi(h_{k}(s))\|ds$ $\displaystyle\leq$
$\displaystyle
M_{0}e^{-\lambda(t-t_{0})}\|x(t_{0})\|+\frac{M_{0}}{\lambda\left(1-\|A\|_{[t_{0},\infty)}\right)}\|A\|_{[t_{0},\infty)}\left(e^{-\lambda(t-t_{0}-\sigma)}-e^{-\lambda(t-t_{0})}\right)\|\Psi\|_{[t_{0}-\sigma,t_{0}]}$
$\displaystyle+\frac{M_{0}}{\lambda\left(1-\|A\|_{[t_{0},\infty)}\right)}\sum_{k=1}^{m}\|B_{k}\|_{[t_{0},\infty)}\left(e^{-\lambda(t-t_{0}-\tau_{k})}-e^{-\lambda(t-t_{0})}\right)\|\Phi\|_{[t_{0}-\tau_{k},t_{0}]},$

which immediately yields (3.4) when $f\equiv 0$.

For any $f$ in (2.1), we employ the above inequality for $\|X(t,s)\|$ and

$\displaystyle\left\|\int_{t_{0}}^{t}X(t,s)[(I-S)^{-1}f](s)\,ds\right\|\leq\frac{M_{0}}{\lambda\left(1-\|A\|_{[t_{0},\infty)}\right)}\|f\|_{[t_{0},t]}.$

∎

######  Theorem 2.

Let $\lambda$ and $\beta$ be positive constants for which

$\mu(P(t))\leq-\beta,\quad t\geq
t_{0},\quad(1+\lambda\sigma)e^{\lambda\sigma}\|A\|_{[t_{0},\infty)}+\sum_{k=1}^{m}\tau_{k}e^{\lambda\tau_{k}}\|B_{k}\|_{[t_{0},\infty)}<1,$
$\begin{array}[]{ll}M_{2}:=&\frac{\lambda+\sum\limits_{k=1}^{m}e^{\lambda\tau_{k}}\|B_{k}\|_{[t_{0},\infty)}+\lambda
e^{\lambda\sigma}\|A\|_{[t_{0},\infty)}}{1-(1+\lambda\sigma)e^{\lambda\sigma}\|A\|_{[t_{0},\infty)}-\sum_{k=1}^{m}\tau_{k}e^{\lambda\tau_{k}}\|B_{k}\|_{[t_{0},\infty)}}\vspace{2mm}\\\
&\displaystyle\times\left(\left\|\frac{A}{\mu(P)}\right\|_{[t_{0},\infty)}\\!\\!\\!\\!\\!\\!(1+\lambda\sigma)e^{\lambda\sigma}+\sum_{k=1}^{m}\left\|\frac{B_{k}}{\mu(P)}\right\|_{[t_{0},\infty)}\\!\\!\\!\\!\\!e^{\lambda\tau_{k}}\tau_{k}\right)<1,\end{array}$

where $P$ is defined in (3.1). Then the solution $x$ of (2.1),(2.2) satisfies
(3.4) with $M_{0}:=(1-M_{2})^{-1}$.

###### Proof.

The proof of the theorem is similar to the proof of Theorem 1 if we use Lemma
2 rather than Lemma 1, (3.5) and the same notation. ∎

Let $m=1$, consider

$\dot{x}(t)-A(t)\dot{x}(g(t))=B(t)x(h(t))+f(t)$ (3.6)

with initial conditions (2.2). Denote

$P_{1}(t):=e^{\lambda(t-h(t))}B(t)-\lambda e^{\lambda(t-g(t))}A(t)+\lambda E.$

######  Corollary 1.

Let $\lambda$ and $\beta$ be positive constants for which

$\mu(P_{1}(t))\leq-\beta,\quad t\geq t_{0},\quad
e^{\lambda\sigma}\|A\|_{[t_{0},\infty)}<1,$ (3.7)
$M_{3}:=\frac{\lambda+e^{\lambda\tau}\|B\|_{[t_{0},\infty)}+\lambda
e^{\lambda\sigma}\|A\|_{[t_{0},\infty)}}{1-e^{\lambda\sigma}\|A\|_{[t_{0},\infty)}}\left(\left\|\frac{A}{\mu(P_{1})}\right\|_{[t_{0},\infty)}\\!\\!\\!\\!\\!\\!\\!\\!\\!\\!(1+\lambda\sigma)e^{\lambda\sigma}+\left\|\frac{B}{\mu(P_{1})}\right\|_{[t_{0},\infty)}\\!\\!\\!\\!\\!\\!\\!\\!\\!\\!e^{\lambda\tau}\tau\right)<1.$
(3.8)

Then for the solution $x$ of problem (3.6),(2.2) and $M_{0}:=(1-M_{3})^{-1}$,
we have

$\begin{array}[]{ll}\|x(t)\|\leq&\displaystyle
M_{0}e^{-\lambda(t-t_{0})}\left[\|x(t_{0})\|+\frac{e^{\lambda\sigma}-1}{\lambda(1-\|A\|_{[t_{0},\infty)})}\|A\|_{[t_{0},\infty)}\|\Psi\|_{[t_{0}-\sigma,t_{0}]}\right.\vspace{2mm}\\\
&\displaystyle\left.+\frac{e^{\lambda\tau}-1}{\lambda(1-\|A\|_{[t_{0},\infty)})}\|B\|_{[t_{0},\infty)}\|\Phi\|_{[t_{0}-\tau,t_{0}]}\right]+\frac{M_{0}}{\lambda(1-\|A\|_{[t_{0},\infty)})}\|f\|_{[t_{0},t]}.\end{array}$
(3.9)

Consider a delay system

$\dot{x}(t)=\sum_{k=1}^{m}B_{k}(t)x(h_{k}(t))+f(t),~{}t\geq
t_{0};~{}~{}x(t)=\Phi(t),~{}t\leq t_{0},$ (3.10)

which is an initial value problem for a particular case of (1.2) without the
neutral part.

Denote

$\displaystyle P_{2}(t):=\sum_{k=1}^{m}e^{\lambda(t-h_{k}(t))}B_{k}(t)+\lambda
E.$

######  Corollary 2.

Let $\lambda$ and $\beta$ be positive constants for which
$\mu(P_{2}(t))\leq-\beta$ for $t\geq t_{0}$ and

$M_{4}:=\left(\lambda+\sum\limits_{k=1}^{m}e^{\lambda\tau_{k}}\|B_{k}\|_{[t_{0},\infty)}\right)\sum_{k=1}^{m}\left\|\frac{B_{k}}{\mu(P_{2})}\right\|_{[t_{0},\infty)}\\!\\!\\!\\!\\!\\!\\!\\!\\!\\!e^{\lambda\tau_{k}}\tau_{k}<1.$

Then, for $M_{0}:=(1-M_{4})^{-1}$, the solution $x$ of problem (3.10)
satisfies

$\|x(t)\|\leq\displaystyle
M_{0}e^{-\lambda(t-t_{0})}\left[\|x(t_{0})\|+\sum_{k=1}^{m}\frac{e^{\lambda\tau_{k}}-1}{\lambda}\|B_{k}\|_{[t_{0},\infty)}\|\Phi\|_{[t_{0}-\tau_{k},t_{0}]}\right]+\frac{M_{0}}{\lambda}\|f\|_{[t_{0},t]}.$

Theorem 2 leads to exponential estimates similar to those in Corollaries 1 and
2.

###  3.2 Exponential stability

Theorems 1 and 2 immediately yield exponential stability conditions.

######  Theorem 3.

Let $\beta$ be a positive constant for which $\displaystyle
B(t):=\sum_{k=1}^{m}B_{k}(t),~{}\mu(B(t))\leq-\beta,~{}\|A\|_{[t_{0},\infty)}<1$
and

$\frac{\sum_{k=1}^{m}\|B_{k}\|_{[t_{0},\infty)}}{1-\|A\|_{[t_{0},\infty)}}\left(\left\|\frac{A}{\mu(B)}\right\|_{[t_{0},\infty)}+\sum_{k=1}^{m}\tau_{k}\left\|\frac{B_{k}}{\mu(B)}\right\|_{[t_{0},\infty)}\right)<1.$
(3.11)

Then equation (1.2) is uniformly exponentially stable.

######  Theorem 4.

Let $\beta$ be a positive constant for which $\mu(B(t))\leq-\beta$, where

$\displaystyle
B(t):=\sum_{k=1}^{m}B_{k}(t),~{}~{}\|A\|_{[t_{0},\infty)}+\sum_{k=1}^{m}\tau_{k}\|B_{k}\|_{[t_{0},\infty)}<1$

and

$\left(\frac{\|B\|_{[t_{0},\infty)}}{1-\|A\|_{[t_{0},\infty)}-\sum_{k=1}^{m}\tau_{k}\|B_{k}\|_{[t_{0},\infty)}}\right)\left(\left\|\frac{A}{\mu(B)}\right\|_{[t_{0},\infty)}+\sum_{k=1}^{m}\tau_{k}\left\|\frac{B_{k}}{\mu(B)}\right\|_{[t_{0},\infty)}\right)<1.$

Then equation (1.2) is uniformly exponentially stable.

For $C=\\{c_{ij}\\}_{i,j=1}^{n}$, denote the matrix
$|C|:=\\{|c_{ij}|\\}_{i,j=1}^{n}$. If $|B(t)|\leq\overline{B}$ for any
$t\in[t_{0},\infty)$, where $\overline{B}$ is a constant matrix, then
$\|B\|_{[t_{0},\infty)}\leq\|\overline{B}\|$.

######  Corollary 3.

Let $\beta$ be a positive constant for which $\mu(B(t))\leq-\beta$, where
$\displaystyle B(t):=\sum_{k=1}^{m}B_{k}(t)$,
$|A(t)|\leq\overline{A},|B_{k}(t)|\leq\overline{B_{k}},|B(t)|\leq\overline{B},\|\overline{A}\|<1$,
and at least one of the following conditions holds:

$\sum_{k=1}^{m}\|\overline{B_{k}}\|\left(\|\overline{A}\|+\sum_{k=1}^{m}\tau_{k}\|\overline{B_{k}}\|\right)<\beta(1-\|\overline{A}\|);$
$\|\overline{B}\|\left(\|\overline{A}\|+\sum_{k=1}^{m}\tau_{k}\|\overline{B_{k}}\|\right)<\beta\left(1-\|\overline{A}\|-\sum_{k=1}^{m}\tau_{k}\|\overline{B_{k}}\|\right).$

Then equation (1.2) is uniformly exponentially stable.

######  Corollary 4.

Let $\beta$ be a positive constant for which $\mu(B(t))\leq-\beta$ for any
$t\geq t_{0}$, $\|A\|_{[t_{0},\infty)}<1$,

$\left(\left\|\frac{A}{\mu(B)}\right\|_{[t_{0},\infty)}+\tau\left\|\frac{B}{\mu(B)}\right\|_{[t_{0},\infty)}\right)\|B\|_{[t_{0},\infty)}<1-\|A\|_{[t_{0},\infty)}.$

Then equation (3.6) with $f\equiv 0$ is uniformly exponentially stable.

######  Corollary 5.

Let $\beta$ be a positive constant for which $\mu(B(t))\leq-\beta$ for any
$t\geq t_{0}$, where $\displaystyle B(t):=\sum_{k=1}^{m}B_{k}(t)$, and either
1)
$\displaystyle\sum_{k=1}^{m}\|B_{k}\|_{[t_{0},\infty)}\sum_{k=1}^{m}\tau_{k}\left\|\frac{B_{k}}{\mu(B)}\right\|_{[t_{0},\infty)}<1$
or
2)
$\displaystyle\|B\|_{[t_{0},\infty)}\sum_{k=1}^{m}\tau_{k}\left\|\frac{B_{k}}{\mu(B)}\right\|_{[t_{0},\infty)}<1-\sum_{k=1}^{m}\tau_{k}\left\|B_{k}\right\|_{[t_{0},\infty)}$
is satisfied. Then, system (3.10) with $f\equiv 0$ is uniformly exponentially
stable.

Consider the system

$\dot{x}(t)=B(t)x(h(t)).$ (3.12)

######  Corollary 6.

Let $\beta$ be a positive constant for which $\mu(B(t))\leq-\beta$ for any
$t\geq t_{0}$, and

$\displaystyle\tau\left\|\frac{B}{\mu(B)}\right\|_{[t_{0},\infty)}\\!\\!\\!\\!\|B\|_{[t_{0},\infty)}<1.$

Then system (3.12) is uniformly exponentially stable.

##  4 Examples and Discussion

First, let us notice that Corollary 6 extends the stability test of
Proposition 1 to a system with a variable delay.

Next, to compare stability tests of the present paper with known ones,
consider a linear scalar neutral differential equation

$\dot{x}(t)-a(t)\dot{x}(g(t))=\sum_{k=1}^{m}b_{k}(t)x(h_{k}(t)),~{}t\geq
t_{0}\geq 0,$ (4.1)

where $|a(t)|\leq a_{0}<1$, $t-g(t)\leq\sigma$, $t-h_{k}(t)\leq\tau_{k}$.
Theorems 3 and 4 imply the following stability tests for scalar equation
(4.1).

######  Corollary 7.

Assume that for some $\beta>0,$ $\displaystyle
b(t):=\sum_{k=1}^{m}b_{k}(t)\leq-\beta<0,~{}t\geq t_{0}$ and either

$\sum_{k=1}^{m}\|b_{k}\|_{[t_{0},\infty)}\left(\left\|\frac{a}{b}\right\|+\sum_{k=1}^{m}\tau_{k}\left\|\frac{b_{k}}{b}\right\|\right)<1-\|a\|_{[t_{0},\infty)}$
(4.2)

or

$\|b\|_{[t_{0},\infty)}\left(\left\|\frac{a}{b}\right\|+\sum_{k=1}^{m}\tau_{k}\left\|\frac{b_{k}}{b}\right\|\right)<1-\|a\|_{[t_{0},\infty)}-\sum_{k=1}^{m}\tau_{k}\|b_{k}\|.$
(4.3)

Then equation (4.1) is uniformly exponentially stable.

Condition (4.2) is known and coincides with [3, Corollary 5.4]. However, the
stability test in (4.3) is new, to the best of our knowledge, and independent
of (4.2) which is illustrated in the following example.

######  Example 1.

Consider a scalar equation with variable oscillating coefficients

$\dot{x}(t)-\nu\left[0.1\sin t~{}\dot{x}(g(t))=-(1-3\cos t)x(t)-(1+3\cos
t)x(h(t))\right],$ (4.4)

where $\nu>0,t-g(t)\leq\sigma,t-h(t)\leq 1=\tau$. Here $m=2$ and

$\|a\|_{[t_{0},\infty)}=0.1\nu,~{}\|b_{1}\|_{[t_{0},\infty)}=\|b_{2}\|_{[t_{0},\infty)}=4\nu,~{}b=b_{1}+b_{2}=-2\nu<0,\tau=1.$

By (4.2) equation (4.4) is uniformly exponentially stable if
$\nu<\frac{1}{16.5}$, by (4.3) the stability condition is $\nu<\frac{1}{8.2}$.
Hence for this equation condition (4.3) is better than (4.2).

In equation (4.4), the value of $\|b_{1}+b_{2}\|_{[t_{0},\infty)}$ is
significantly less than
$\|b_{1}\|_{[t_{0},\infty)}+\|b_{2}\|_{[t_{0},\infty)}$. If they are close,
condition (4.2) is better than (4.3). For example, if the term of $3\cos t$ is
omitted in the coefficients in (4.4), estimate in (4.2) becomes sharper than
in (4.3) ($\nu<\frac{1}{2.2}$ compared to $\nu<\frac{1}{3.2}$, respectively).

Note that all coefficients in (4.4) of Example 1 are oscillating, while most
known stability tests even for equations without the neutral part deal with
positive coefficients.

To compare the results of the present paper with known stability tests, we
adapt Theorems 3 and 4 to a non-autonomous equation generalizing (1.4)

$\dot{x}(t)-A_{1}(t)\dot{x}(H_{1}(t))=A_{0}(t)x(t)+A_{2}(t)x(H_{2}(t)),~{}t\geq
t_{0},$ (4.5)

where $0\leq t-H_{1}(t)\leq h_{1},0\leq t-H_{2}(t)\leq h_{2}$ for some
$h_{1},h_{2}>0$.

######  Corollary 8.

Assume that for some $\beta>0$, $\mu(A_{0}(t)+A_{2}(t))\leq-\beta<0,~{}t\geq
t_{0}$ and at least one of the following conditions holds:

$\displaystyle\|A_{1}\|_{[t_{0},\infty)}<1,~{}-\beta+\frac{(\|A_{0}\|_{[t_{0},\infty)}+\|A_{2}\|_{[t_{0},\infty)})(\|A_{1}\|_{[t_{0},\infty)}+h_{2}\|A_{2}\|_{[t_{0},\infty)})}{1-\|A_{1}\|_{[t_{0},\infty)}}<0;$
(4.6)

$\displaystyle\|A_{1}\|_{[t_{0},\infty)}+h_{2}\|A_{2}\|_{[t_{0},\infty)}<1,~{}-\beta+\frac{\|A_{0}+A_{2}\|_{[t_{0},\infty)}(\|A_{1}\|_{[t_{0},\infty)}+h_{2}\|A_{2}\|_{[t_{0},\infty)})}{1-\|A_{1}\|_{[t_{0},\infty)}-h_{2}\|A_{2}\|_{[t_{0},\infty)}}<0.$
(4.7)

Then equation (4.5) is uniformly exponentially stable.

###### Proof.

Assume first that (4.6) holds. We will apply Theorem 3 for $m=2$ to equation
(4.5). Inequality (3.11) for (4.5) has the form

$\frac{\|A_{0}\|_{[t_{0},\infty)}+\|A_{2}\|_{[t_{0},\infty)}}{1-\|A_{1}\|_{[t_{0},\infty)}}\left(\left\|\frac{A_{1}}{\mu(A_{0}+A_{2})}\right\|_{[t_{0},\infty)}+h_{2}\left\|\frac{A_{2}}{\mu(A_{0}+A_{2})}\right\|_{[t_{0},\infty)}\right)<1,$

which, due to $|\mu(A_{0}(t)+A_{2}(t))|\geq\beta$, yields that

$\frac{\|A_{0}\|_{[t_{0},\infty)}+\|A_{2}\|_{[t_{0},\infty)}}{1-\|A_{1}\|_{[t_{0},\infty)}}\left(\|A_{1}\|_{[t_{0},\infty)}+h_{2}\|A_{2}\|_{[t_{0},\infty)}\right)<\beta.$
(4.8)

Inequality (4.8) is equivalent to the second inequality in (4.6).

All conditions of Theorem 3 hold for equation (4.5), hence this equation is
uniformly exponentially stable.

The second part of the corollary follows from Theorem 4 and is justified in a
similar way. ∎

Proposition 2 is independent of Proposition 3 and of Corollary 8. Condition
(4.6) in Corollary 8 is independent of both propositions and of the stability
test in (4.7), while (4.7) coincides with Proposition 3 in the case of
constant coefficients and delays.

Several stability results for linear neutral systems were obtained by the LMI
method based on Lyapunov-Krasovskii functionals. Usually neutral systems
studied by the LMI method have constant matrix coefficients and bounded
derivatives of delay functions.

Consider now the following example of a non-autonomous system of neutral type
with variable matrix coefficients $n\times n$. Note that with the growth of
dimension the calculations in LMI increase dramatically.

######  Example 2.

Consider system (1.2) for $m=2$

$\dot{x}(t)-A(t)\dot{x}(g(t))=B_{1}(t)x(h_{1}(t))+B_{2}(t)x(h_{2}(t)),~{}~{}t\geq
t_{0}\geq 0,$ (4.9)

where $B_{1}(t)=\sin^{2}t~{}C$, $B_{2}(t)=\cos^{2}t~{}C$, $C$ is a tri-
diagonal and $A$ is a variable matrix

$C=\begin{pmatrix}-\alpha&\beta&0&0&\dots&0&0\\\
\beta/2&-\alpha&\beta/2&0&\dots&0&0\\\ 0&\beta/2&-\alpha&\beta/2&\dots&0&0\\\
\vdots&\vdots&\vdots&\vdots&\vdots&\vdots&\vdots\\\
0&0&0&0&\dots&\beta&-\alpha\end{pmatrix},~{}~{}A=\gamma\begin{pmatrix}\cos
t&\cos 2t&\cos 3t&\dots&\cos nt\\\
\cos^{2}t&\cos^{2}2t&\cos^{2}3t&\dots&\cos^{2}nt\\\
\vdots&\vdots&\vdots&\vdots&\vdots\\\
\cos^{n}t&\cos^{n}2t&\cos^{n}3t&\dots&\cos^{n}nt\\\ \end{pmatrix},$

$\alpha>0,h_{1}(t)=t-0.1|\sin t|,h_{2}(t)=t-0.1|\cos t|,t-g(t)\leq\sigma$. We
have for the norm $\|\cdot\|_{[0,\infty)}$:

$\|A\|_{[0,\infty)}=n|\gamma|,~{}~{}\tau_{i}=\sup_{t\geq
0}(t-h_{i}(t))=0.1,~{}~{}\|B_{i}\|_{[0,\infty)}=\alpha+|\beta|,~{}i=1,2,$

$B=B_{1}+B_{2}$, $\mu(B)=-\alpha+|\beta|$. Let

$|\beta|<\alpha,~{}n|\gamma|<1,~{}2(\alpha+|\beta|)[n|\gamma|+0.2(\alpha+|\beta|)]<(1-n|\gamma|)(\alpha-|\beta|).$
(4.10)

Then, by Theorem 3 equation (4.9) is uniformly exponentially stable.

In particular, conditions (4.10) hold for $\alpha=0.4$, $|\beta|=0.1$,
$n|\gamma|=0.01$.

Assume in addition $\|A\|=n|\gamma|=0.01$, $\lambda=0.06$, $\sigma=0.1$. Hence
$\|B_{i}\|_{[0,\infty)}=0.5$, $\mu(C)=-0.3$ and calculate by Theorem 1 an
estimate for solution $x$ of the equation

$\dot{x}(t)-A(t)\dot{x}(g(t))=B_{1}(t)x(h_{1}(t))+B_{2}(t)x(h_{2}(t))+f(t),~{}~{}t\geq
t_{0}\geq 0,$ (4.11)

with initial condition (2.2). We have

$\displaystyle\mu(P(t))=$
$\displaystyle\mu\left(e^{\lambda(t-h_{1}(t))}B_{1}(t)+e^{\lambda(t-h_{2}(t))}B_{2}(t)-\lambda
e^{\lambda(t-g(t))}A(t)+\lambda E\right)$
$\displaystyle\leq\mu\left(e^{\lambda(t-h_{1}(t))}B_{1}(t)+e^{\lambda(t-h_{2}(t))}B_{2}(t)\right)+\mu\left(-\lambda
e^{\lambda(t-g(t))}A(t)\right)+\mu(\lambda E).$

Then

$\mu\left(e^{\lambda(t-h_{1}(t))}B_{1}(t)+e^{\lambda(t-h_{2}(t))}B_{2}(t)\right)=\left(e^{\lambda(t-h_{1}(t))}\sin^{2}t+e^{\lambda(t-h_{2}(t))}\cos^{2}t\right)\mu(C).$

Since $\mu(C)=-0.3<0$ and

$e^{\lambda(t-h_{1}(t))}\sin^{2}t+e^{\lambda(t-h_{2}(t))}\cos^{2}t\geq\sin^{2}t+\cos^{2}t=1,$

we get

$\mu\left(e^{\lambda(t-h_{1}(t))}B_{1}(t)+e^{\lambda(t-h_{2}(t))}B_{2}(t)\right)\leq\mu(C)=-0.3.$

Next,

$\mu\left(-\lambda e^{\lambda(t-g(t))}A(t)\right)\leq\lambda
e^{\lambda(t-g(t))}\|A\|_{[0,\infty)}\leq 0.0006e^{0.006},~{}\mu(\lambda
E)=\lambda=0.06.$

Then $\mu(P(t))\leq-0.23939<0$ and

$M_{1}:=\frac{\lambda+\sum\limits_{k=1}^{2}e^{\lambda\tau_{k}}\|B_{k}\|_{[t_{0},\infty)}+\lambda
e^{\lambda\sigma}\|A\|_{[t_{0},\infty)}}{1-e^{\lambda\sigma}\|A\|_{[t_{0},\infty)}}\left(\left\|\frac{A}{\mu(P)}\right\|_{[t_{0},\infty)}\\!\\!\\!\\!\\!\\!\\!\\!\\!\\!(1+\lambda\sigma)e^{\lambda\sigma}+\sum_{k=1}^{2}\left\|\frac{B_{k}}{\mu(P)}\right\|_{[t_{0},\infty)}\\!\\!\\!\\!\\!\\!\\!\\!\\!\\!e^{\lambda\tau_{k}}\tau_{k}\right).$

By numerical calculations, $M_{1}\leq 0.5$ and $M_{0}=(1-M_{1})^{-1}\leq 2$.
For the solution $x$ of problem (4.11),(2.2) we have (here we omitted the norm
indices)

$\|x(t)\|\leq\left.\left.2e^{-0.06(t-t_{0})}\right[\|x(t_{0})\|+0.00102\|\Psi\|+0.102\|\Phi\|\right]+33.6\|f\|,~{}t\geq
t_{0}\geq 0.$

Let us conclude with some additional comments. Several explicit stability
conditions for delay and neutral systems were obtained by application of the
Bohl-Perron theorem [1, 5, 6, 7, 9, 11]. In general, these tests do not
coincide with results of this paper even in the scalar case, see discussion in
[4]. However, some conditions can be the same, for example, Corollary 5 of the
present paper and [7, Corollary 1] coincide.

In interesting papers [24, 25], the authors study neutral systems in the Hale
form. They obtained explicit exponential stability conditions for rather
general linear neutral systems. The method applied in [24, 25] is based on
some specific spectral matrix properties, such as a Metzler matrix with non-
negative off-diagonal entries.

Fixed point methods also lead to explicit stability condition, but so far they
were applied only to scalar neutral equations, and used the first and the
second derivatives of delay functions. The advantage of fixed point approach
is that it can also be applied to nonlinear equations. The method described
here is only considered for linear systems.

Finally, we suggest some relevant topics for future research.

  1. 1.

Here we used the essential supremum norm which led to exponential stability
tests including essential supremum estimates. It would be interesting to get
integral stability conditions for neutral systems considered in the paper, for
the scalar case see [3, Theorem 4.7].

  2. 2.

Obtain stability conditions assuming that either delays or coefficients, or
both, can be unbounded.

  3. 3.

Investigate exponential stability for neutral systems of a higher order.

  4. 4.

Are uniform asymptotic stability and uniform exponential stability equivalent
for linear neutral systems with bounded delays? For equations without a
neutral term this is known [16, 21].

## Acknowledgment

E. Braverman was partially supported by NSERC, the grant RGPIN-2020-03934. The
authors are very grateful to the anonymous referees whose thoughtful comments
significantly contributed to the quality of presentation.

## References

  * [1] N. V. Azbelev and P. M. Simonov, Stability of Differential Equations with Aftereffect. Stability and Control: Theory, Methods and Applications, 20. Taylor $\&$ Francis, London, 2003\.
  * [2] M. V. Barbarossa and H.-O. Walther, Linearized stability for a new class of neutral equations with state-dependent delay, Differ. Equ. Dyn. Syst. 24 (2016), 63–79.
  * [3] L. Berezansky and E. Braverman, On stability of linear neutral differential equations with variable delays, Czechoslovak Math. J. 69(144) (2019), 863–891.
  * [4] L. Berezansky and E. Braverman, A new stability test for linear neutral differential equations, Appl. Math. Lett. 108 (2020), 106515, doi https://doi.org/10.1016/j.aml.2020.106515.
  * [5] L. Berezansky, J. Diblík, Z. Svoboda and Z. Šmarda, Exponential stability of linear delayed differential systems, Appl. Math. Comput. 320 (2018), 474–484.
  * [6] L. Berezansky, J. Diblík, Z. Svoboda and Z. Šmarda, Exponential stability tests for linear delayed differential systems depending on all delays, _J. Dynam. Diff. Equat._ 31 (2019), 2095–2108.
  * [7] L. Berezansky, J. Diblík, Z. Svoboda and Z. Šmarda, Simple uniform exponential stability tests for linear delayed vector differential equation, submitted.
  * [8] W. A. Coppel, Dichotomies in stability theory. Lecture Notes in Mathematics, 629 Springer-Verlag, Berlin-New York, 1978.
  * [9] A. Domoshnitsky, M. Gitman and R. Shklyar, Stability and estimate of solution to uncertain neutral delay systems, Bound. Value Probl. 2014, 2014:55, 14 pp.
  * [10] E. Fridman, New Lyapunov-Krasovskii functionals for stability of linear retarded and neutral type systems, Systems Control Lett. 43 (2001), 309–319.
  * [11] M. I. Gil’, Stability of Neutral Functional Differential Equations, Atlantis Studies in Differential Equations, 3. Atlantis Press, Paris, 2014.
  * [12] K. Gopalsamy, A simple stability criterion for linear neutral differential systems, Funkcialaj Ekvacioj, 28 (1985), 33–38.
  * [13] K. Gopalsamy, Stability and Oscillations in Delay Differential Equations of Population Dynamics. Mathematics and its Applications, 74. Kluwer Academic Publishers Group, Dordrecht, 1992.
  * [14] I. Győri and M. Pituk, Special solutions of neutral functional differential equations, J. Inequal. Appl. 6 (2001), 99–117.
  * [15] I. Győri and F. Hartung, Preservation of stability in a linear neutral differential equation under delay perturbations, Dynam. Systems Appl.  10 (2001), 225–242.
  * [16] J. K. Hale and S. M. Verduyn Lunel, Introduction to Functional Differential equations. Applied Mathematical Sciences, 99. Springer-Verlag, New York, 1993.
  * [17] Q.-L. Han, Stability criteria for a class of linear neutral systems with time-varying discrete and distributed delays, IMA J. Math. Control Inform. 20 (2003), 371–386.
  * [18] C. Jin and J. Luo, Fixed points and stability in neutral differential equations with variable delays, Proc. Amer. Math. Soc.  136 (2008), 909–918.
  * [19] V. Kolmanovskii and A. Myshkis, Introduction to the Theory and Applications of Functional-Differential Equations, Mathematics and its Applications 463, Kluwer Academic Publishers, Dordrecht, 1999\.
  * [20] V. B. Kolmanovskiǐ and V. R. Nosov, Stability of Functional-Differential Equations, Mathematics in Science and Engineering 180, Academic Press, London, 1986.
  * [21] A. Kulikov and V.Malygina, On relation between uniform asymptotic stability and exponential stability of linear differential equations, Electron. J. Qual. Theory Differ. Equ. 2015, No. 65, 8 pp.
  * [22] M. Liu, Global exponential stability analysis for neutral delay-differential systems: an LMI approach, Internat. J. Systems Sci. 37 (2006), 777–783.
  * [23] L. M. Li, Stability of linear neutral delay-differential systems, Bull. Austral. Math. Soc. 38 (1988), 339–344.
  * [24] P. H. A. Ngoc and Q. Ha, On exponential stability of linear non-autonomous functional differential equations of neutral type, Internat. J. Control 90 (2017), 454–462.
  * [25] P. H. A. Ngoc and N. Trinh, Novel criteria for exponential stability of linear neutral time-varying differential systems, IEEE Trans. Automat. Control 61 (2016), 1590–1594.
  * [26] J. H. Park and S. Won, Stability analysis for neutral delay-differential systems, J. Franklin Inst. 337 (2000), 1–9.
  * [27] L. Shaikhet, Lyapunov Functionals and Stability of Stochastic Functional Differential Equations, Springer, Dordrecht, Heidelberg, New York, London, 2013.
  * [28] G. Söderlind, The logarithmic norm. History and modern theory, _BIT_ 46 (2006), 631–652.
  * [29] Z. Zahreddine, Matrix measure and application to stability of matrices and interval dynamical systems, _Int. J. Math. Math. Sci._ 2003:2 (2003), 75–85.
  * [30] D. Zhao, New criteria for stability of neutral differential equations with variable delays by fixed points method, _Adv. Difference Equ._ 2011:48 (2011), 11 pp.