In RavenDB 4.0 (yes, that is quite a bit away), we are working on additional data types and storage engines. One of the things that we’ll add, for example, is the notion of gossiping distributed counters. That doesn’t actually matter for our purposes here, however.
What I wanted to talk about today is the problem in making small updates over a network. Consider the counters example. By far the most common operations are some variant of:
Since the database is remote, we need to send that over the network. But that is a very small operation. Going all the way to the remote database just for that is a big waste of time. Consider that in most systems, we don’t have just a single thread of execution, we have many. Each of them performing their own operations. Allowing each operation to go on its own is a big waste, but what other options can we offer?
There are other considerations as well. While most of the time we’ll be making small operations, it is very common to need to do bulk operations as well. Maybe you are setting up the system for the first time, or importing data from a file, etc. Making large number of individual requests will kill any hope of doing this fast. The obvious answer is to use batching. send a lot of values to the server all at once. This reduce the network overhead significantly.
The API for that would be something like:
using(var batch = counters.Advanced.NewBatch())
foreach(var line in File.EnumerateAllLines("counters.csv"))
var parts = line.Split();
So that is great for big things, but not very helpful for individual operations. We still have to go to the server for each of those.
Of course, we could also use the batch API, but making use of that for an individual operation is… a big waste.
What to do?
The end result we arrived at was that we have three levels of API:
counters.Increment(name, 1);– single operation, executed immediately over the network. Guaranteed to succeed or fail and give you the result.
counters.Advanced.NewBatch()– batch operation, executed over all of the items in the batch (but not as a single transaction), will let you know if the whole operation succeeded, or if there was an issue with something.
counters.Batch.Increment()– the default batch, thread safe, can be utilized by individual requests. This is a fire & forget operation. We increment, and behind the scene we’ll merge all the increment from all the threads and send them in batches to the server.
Note that the last option means that we’ll only do batches, so only when enough time has lapsed or we have enough items to send will we send the data to the server. The idea is that you get to choose, based on the importance of what you are doing.
If you need confirmation that something was successful, use the individual operation. If you just want us to make best effort, and if something bad really happened you don’t care about it, use the batch option.
Note that I’m using the counters example here because it is simple, but the same applies for things like time series, and other stuff that we are currently building.
|Reference:||API Design. Small modifications over a network from our NCG partner Oren Eini at the Ayende @ Rahien blog.|