Over a million developers have joined DZone.

The Low-Hanging Fruit of Read Transaction Startup

DZone's Guide to

The Low-Hanging Fruit of Read Transaction Startup

See how Ayende Rahien handles the startup process for read transactions in order to boost performance.

· Database Zone
Free Resource

Learn how to create flexible schemas in a relational database using SQL for JSON.

A benchmark in question deals with service 1 million random documents, as fast as possible. In my previous series, I detailed how we were able to reduce the cost of finding the right database to about 1.25% of the cost of the request (down from about 7-8%). In this post, we are going to tackle the next problem:

Image title

So 14% of the request times goes into just opening a transaction?! Well, that make sense, surely that means that there is a lot going on there, some I/O, probably. The fact that we can do that in less than 50 micro seconds is pretty awesome, right?

Not quite, let us look at what is really costing us here.

Image title

Just look at all of those costs, all of this isn’t stuff that you just have to deal with because there is I/O involved, let us look at the GetPagerStatesOfAllScratches, shall we?

Image title

I’ll just sit down and cry now, if you don’t mind. Here is what happens when you take this code and remove the Linqness.

This is purely a mechanical transformation, we have done nothing to really change things. And here is the result:

Image title

Just this change reduced the cost of this method call by over 100%! As this is now no longer our top rated functions, we’ll look at the ToList now.

This method is called from here:

Image title

And here is the implementation:

Image title

And then we have:

Image title

Image title

Well, at least my job is going to be very easy here. The interesting thing is that the Any() call can be removed / moved to DEBUG only. I changed the code to pass the JournalSnapshots into the GetSnapshots, saving us an allocation and all those Any calls. That gave us:

Image title

So far, we have managed to reduce ten seconds out of the cost of opening a transaction. We have done this not by being smart of doing anything complex. We just looked at the code and fixed the obvious performance problems in it.

Let’s see how far that can take us, shall we?

The next observation I had was that Transaction is actually used for both read and write operations. And that there is quite a bit of state in the Transaction that is only used for writes. However, this is actually a benchmark measuring pure read speed, so why should we be paying all of those costs needlessly? I basically moved all the field initializers to the constructor, and only initialize them if we are using a write transaction. Just to give you some idea, here is what I moved:

Image title

So those are six non trivial allocations that have been moved from the hot path, and a bunch of memory we won’t need to collect. As for the impact?

Image title

We are down to about half of our initial cost! And we haven’t really done anything serious yet. This is quite an awesome achievement, but we are not done. In my next post, we’ll actually move to utilizing our knowledge of the code to make more major changes in order to increase overall performance.

Create flexible schemas using dynamic columns for semi-structured data. Learn how.

database ,database performance ,optimization ,read

Published at DZone with permission of Oren Eini, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.


Dev Resources & Solutions Straight to Your Inbox

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.


{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}