Infrastructure at your Service

David Barbarin

SQL Server 2016 : availability groups and performance improvements

During the last SQL Saturday in Paris, I had the opportunity to co-present the new SQL Server 2016 features and one of my topic concerned the availability group’s enhancements. I mentioned the replication throughput improvement but without giving more details and this is the idea of this blog post.

First of all, let’s remind that the network throughput is part of the synchronous replication process and it is directly tied to the application transaction performance. Indeed, even if availability groups have an enhanced replication process compared to the mirroring feature (e.g. log blocks are sent to the secondary replicas in parallel), the client must still wait the commit acknowledgment from all the replicas before processing other transactions. So improving the availability group replication stuff has become a major issue in mission-critical performance business that includes In-Memory technologies.

I decided to take a look at this topic and I ran some performance tests between SQL Server 2014 SP1 and SQL Server 2016 CTP 2.3.

But let’s first introduce my environment lab. It that consists of two virtualized servers (Windows Server 2012) on the top of Hyper-V. The Hyper-V server runs on my Windows 8 laptop with the following characteristics:

  • Intel Core i7-3630QM 2.4 GHz – Quad core
  • 16GB of memory
  • The storage includes 2 disks: Samsung 840 EVO 250GB that will host the database data files and the In-Memory CFPs and Samsung MS-PU500 500GB that will host for the transaction log files)

The tests will be performed on the third machine on the virtual environment with 8 VCPU and 1GB of memory. As you may notice, some pieces of my environment are not so scalable and to be honest, before to begin, I wondered if I could get the expected results. But keep motivated and let’s perform some tests.

Here a simplified schema of my availability group environment:

 

blog 68- 1 - lab environment

My test is pretty simple and the idea is to generate sufficient concurrent workload that will issue update operations against one In-Memory durable table.

Here the DDL script of the insert_in_memory_0 in-memory table:

CREATE TABLE [dbo].[insert_in_memory0]
(
	[id] [int] IDENTITY(1,1) NOT NULL,
	[col1] [varchar](8000) COLLATE French_CI_AS NULL,

 PRIMARY KEY NONCLUSTERED HASH 
(
	[id]
)WITH ( BUCKET_COUNT = 1048576)
)WITH ( MEMORY_OPTIMIZED = ON , DURABILITY = SCHEMA_AND_DATA )

The insert_in_memory_0 table already contains 5000 records. This table consumes 63MB of memory space.

select 
	memory_allocated_for_table_kb / 1024 as mem_alloc_table_MB,
	memory_allocated_for_indexes_kb / 1024 as mem_allo_index_MB,
	memory_used_by_table_kb / 1024 as mem_used_table_MB,
	memory_used_by_indexes_kb / 1024 as mem_used_index_MB
from sys.dm_db_xtp_table_memory_stats
where object_id = object_id('insert_in_memory0')

blog 68- 91 - in memory memory space used

And the DDL script for the native compile stored procedure used for update operations:

create procedure [dbo].[pr_always_workload_upd_xtp]
WITH NATIVE_COMPILATION, SCHEMABINDING, EXECUTE AS OWNER
as
BEGIN ATOMIC 
 WITH (TRANSACTION ISOLATION LEVEL = SNAPSHOT, LANGUAGE = N'us_english')

declare @i int;
declare @i2 int;
declare @i3 int;


	set @i = rand() * 1000
	set @i2 = rand() * 10
	set @i3 = @i * @i2;

	update [dbo].[insert_in_memory0]
	set col1 = 'tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt'
	where id = @i3;
END

According to the Microsoft documentation here, I implemented different data collectors to monitor the performance of my availability groups.

blog 68- 9 - alwayson monitoring components

I had a specific focus on the points 2 and 3 in this context because they concerned the transport layer and I wanted to check the potential improvement in this topic. Here the results of my tests:

  • On the primary replica
blog 68- 3 - batch requests per sec blog 68- 4 - mirrored transactions per sec
blog 68- 5 - bytes sent to replica per sec

Well. I can see an interesting performance improvement between my two availability groups (SQL14 and SQL16) in terms of transaction performance (~2x in my case). I also noticed a slightly processor usage with SQL Server 2016 but this is an expected behaviour because the system is able to handle more batches and transactions per second. Finally, it seems that the network traffic is more important with SQL Server 2016 and it requires a well-designed network bandwidth.

  • On the secondary replica
blog 68- 6 - Log Bytes Received per sec blog 68- 7 - Redone Bytes per sec

From the secondary replica, I also noticed some improvements on the AlwaysOn transport layer. In my case, the system is able to handle 1.5x the log stream of SQL Server 2014 and this is probably part of the global improvement of the overall performance. In addition, the redo thread activity is more important on SQL Server 2016 (we received more log records to redone) but I don’t believe that we’ve reached the limit of the redo thread from my tests. Unfortunately, I don’t have enough resources to perform further tests.

  • Log drive
blog 68- 42 - primary log disk throughput blog 68- 41 - primary log disk latency
blog 68- 8 - Disk throughput blog 68- 81 - Disk latency

My SSD drive (Samsung MS-PU500 model) handled correctly the transaction log activity with a low latency on both replicas (< 2ms) and was not a source of bottlenecks. But once again, I can’t perform further tests because I’m already limited in terms of resources on my laptop.

Here a picture of I/O statistics for the concerned database log file in each case:

blog 68- 92 - io stats log file

The bottom line

In this blog post, we’ve seen that SQL Server 2016 AlwaysOn and availability groups feature provide some interesting improvements about the log transport. Of course we’re far from reaching the improvement limits in this context. Anyway, we may guess that this improvement was necessary to scale In-memory tables. Keep in mind that Microsoft provided some other performance improvements for In-memory tables. In fact, the storage layer has been overhauled to scale better with new hardware machines and modern CPU architectures. I’m looking forward to test the potential new improvements with next SQL Server 2016 CTP releases!

 

 

 

Leave a Reply


+ 8 = ten

David Barbarin
David Barbarin

Senior Consultant & Microsoft Technology Leader