These are the wrong sort of bees

balanced vs unbalanced

Sun, 30 Oct 2022 09:31:00 +0300

Or why Dragonfly is winning hearts of developers…

Dragonfly Cache Design

Thu, 23 Jun 2022 12:00:00 +0300

I talked in my previous post about Redis eviction policies. In this post, I would like to describe the design behind Dragonfly cache.

Redis Analysis - Part 2: Simplicity

Sun, 30 Jan 2022 20:00:00 +0200

Let’s talk about the simplicity of Redis. Redis was initially designed as a simple store, and it seems that its APIs achieved this goal. Unfortunately, Redis’s simple design makes it unreliable and difficult to manage in production.

So the question is - what simplicity means to you as a datastore user?

Redis Analysis - Part 1: Threading model

Thu, 09 Dec 2021 11:00:00 +0300

Following my previous post, we are going start with the “hottest potato” - single-threaded vs multi-threaded argument.

A prelude to analysis of Redis memory-store

Sun, 28 Nov 2021 17:46:19 +0300

During the last 13 years, Redis has become a truly ubiquitous memory store that has won the hearts of numerous dev-ops and software engineers. Indeed, according to StackOverflow survey in 2021, Redis is the most loved database for the 5th time in a row and is at the top of db-engines ranking, way before the next contestant. But how well does Redis utilizes modern hardware systems? Will it stay competitive in a few years without reinventing itself?

Gaia Mapreduce Tutorial - part2

Fri, 01 Nov 2019 10:30:12 +0300

In part 1 of my tutorial I’ve explained behind the scenes of a typical mapreduce framework. In this section we will go over GAIA-MR and will show why it’s more efficiant than other open-source frameworks.

Benchmarking GAIA MR on Google cloud

Thu, 25 Jul 2019 11:38:01 +0300

I’ve recently had a chance to benchmark GAIA in Google cloud. The goal was to test how quickly I can process compressed text data (i.e read and uncompress on the fly) when running on a single VM and reading directly from cloud storage. The results were quite surprising.

Gaia Mapreduce Tutorial - part1

Mon, 15 Jul 2019 00:00:35 +0300

There are many Java-based mapreduce frameworks that exist today - Apache Beam, Flink, Apex are to name few.

GAIA-MR is my attempt to show advantages of a C++ over other languages in this domain. It’s currently implemented for a single machine but even with this restriction I’ve seen up-to 3-7 times reduction in cost and running time vs current alternatives.

Please note that the single machine restriction put a hard limit on how much data we can process, nethertheless GAIA-MR shines with small-to-medium size workloads (~1TB). This part gives an introduction about mapreduce in general.

Introduction to fibers in c++

Sat, 15 Dec 2018 11:59:52 +0300

In my post about Seastar we’ve covered continuations style asynchronous programming. My personal opinion is that this style is hard to work with in C++. In this post I would like to cover alternative, Fiber-based approach. I will use Boost.Fibers library in all my examples. Fibers, or green threads, or cooperative threads are similar to regular threads but with few important distinctions: Fibers can not move between system threads and they are usually pinned to a specific thread.

Seastar - Asynchronous C++ framework

Thu, 12 Jul 2018 20:45:24 +0300

Lately, there are many discussions in the programming community in general and in c++ community in particular on how to write efficient asynchronous code. Many concepts like futures, continuations, coroutines are being discussed by c++ standard committee but not much progress was made besides very minimal support of C++11 futures.

On the other hand, many mainstream programming languages progressed quicker and adopted asynchronous models either into a core language or popularized it via standard libraries. For example, Python (yield) and Lua use coroutines to achieve asynchronisity, java uses continuations and futures, golang and Erlang use green threads, and C and Javascript use callback based actor models. However, C++ historically lacked the official support for asynchronous programming, which forced the community to introduce ad-hoc frameworks and libraries that provided this functionality.

I would like to share my opinion on what I think will be the best direction for asynchronous models in C++ by reviewing two prominent frameworks: Seastar and Boost.Fiber. This (opinionated) post reviews Seastar.

Implementing cheap and precise clock

Thu, 02 Nov 2017 13:37:51 +0200

The posix API for querying high-precision hardware clocks is clock_gettime. If one second precision is fine then time(nullptr) is your friend. Unfortunately, using precice clocks takes its price - they are more expensive CPU-wise.

Reloading data structures under high throughput

Fri, 29 Sep 2017 15:46:55 +0300

Suppose you have a multi-threaded server that serves tens of thousands read queries per second. Those queries use a shared data-structure or index that is mostly immutable during the server run with the exception of periodic index reloads. How do you implement data reloads in that server while keeping it live and kicking in production?

How to serialize integers into memory

Tue, 26 Sep 2017 22:46:30 +0300

Here is the analysis of a recent bug I’ve stumbled upon. My initial reaction was that the problem is in the compiler (or that “These are wrong bees”). Consider the code below. We copy 64 integers into a properly allocated destination buffer and yet, if compiled with -O3 switch this code crashes with segfault!

My first post

Tue, 26 Sep 2017 16:16:40 +0300

Hi it’s my first attemp at blogging. I’ve chosen Hugo with Icarus theme for the content generation. This blog is going to be published vi my github repository. Stay tuned!