Category

Blog on All Things Cloud Foundry

Performance Comparison of Ruby Frameworks, App Servers, Template Engines, and ORMs (2016)

Eugene Melnikov

performance-ruby-rails-sinatra-rack

The Ruby ecosystem is constantly evolving. There have been many changes in the engineering world since our comparison of Ruby frameworks in 2014. During the two years, we received a few requests from fellow engineers asking for an updated benchmark. So, here is the 2016 edition with more things tested.

(more…)

24 Comments

Performance Evaluation: MongoDB over NetApp E-Series

Vladimir Starostenkov

mongodb_over_netapp_e_series-v1

NetApp, a provider of high-performing data storage systems, has been working on adjusting its offerings to the requirements of NoSQL databases (such as MongoDB). As a result, the company now offers two MongoDB-certified flash storage solutions. Altoros joined the effort to evaluate these products.

This blog post reveals some of the performance results for the MongoDB integrated architecture deployed to NetApp E-Series.

(more…)

No Comments

Golang Internals, Part 6: Bootstrapping and Memory Allocator Initialization

Siarhei Matsiukevich

Go Gopher

All parts: Part 1 | Part 2 | Part 3 | Part 4 | Part 5 | Part 6

This post is the continuation of our Golang Internals series. It explores the bootstrapping process, which is key to understanding the Go runtime, in more detail. In this part, we will run through the second portion of the starting sequence, learn how arguments are initialized, what functions are called, etc.

(more…)

2 Comments

Golang Internals, Part 5: the Runtime Bootstrap Process

Siarhei Matsiukevich

Golang Internals Go Runtime and BootstrappingAll parts: Part 1 | Part 2 | Part 3 | Part 4 | Part 5 | Part 6
 
The bootstrapping process is the key to understanding how the Go runtime works. Learning it is essential, if you want to move forward with Go. So the fifth installment in our Golang Internals series is dedicated to the Go runtime and, specifically, the Go bootstrap process. This time you will learn about:

  • Go bootstrapping
  • resizable stacks implementation
  • internal TLS implementation

Note that this post contains a lot of assembler code and you will need at least some basic knowledge of it to proceed (here is a quick guide to Go’s assembler). So let’s get going!

 
(more…)

3 Comments

Golang Internals, Part 4: Object Files and Function Metadata

Siarhei Matsiukevich

Golang-Part-4-Object-Files-and-Function-MetadataAll parts: Part 1 | Part 2 | Part 3 | Part 4 | Part 5 | Part 6

Today, we’ll take a closer look at the Func structure and discuss a few details on how garbage collection works in Go.

This post is a continuation of “Golang Internals, Part 3: The Linker and Go Object Files” and uses the same sample program. So, if you haven’t read it, I strongly advise that you do this before moving forward.
 
(more…)

No Comments

Golang Internals, Part 3: The Linker, Object Files, and Relocations

Siarhei Matsiukevich

All parts: Part 1 | Part 2 | Part 3 | Part 4 | Part 5 | Part 6

15-03-11-Golang_Internals_the_Linker_and_Object_filesToday, I will speak about the Go linker, Go object files, and relocations.

Why should we care about these things? Well, if you want to learn the internals of any large project, the first thing you need to do is split it into components or modules. Second, you need to understand what interface these modules provide to each other. In Go, these high-level modules are the compiler, linker, and runtime. The interface that the compiler provides and the linker consumes is an object file and that’s where we will start our investigation today.
 
(more…)

No Comments

Golang Internals, Part 2: Diving Into the Go Compiler

Siarhei Matsiukevich

golang-internals-the-go-compiler

All parts: Part 1 | Part 2 | Part 3 | Part 4 | Part 5 | Part 6
 
Do you know what exactly happens in the Go runtime, when you use a variable via interface reference? This is not a trivial question, because in Go a type that implements an interface does not contain any references to this interface whatsoever. Still, we can try answering it, using our knowledge of the Go compiler, which was discussed in the previous blog post.

So, let’s take a deep dive into the Go compiler: create a basic Go program and see the internal workings of the Go typecasting. Using it as an example, I’ll explain how a node tree is generated and utilized. So, you can further apply this knowledge to other Go compiler’s features.
 
(more…)

3 Comments

Golang Internals, Part 1: Main Concepts and Project Structure

Siarhei Matsiukevich

All parts: Part 1 | Part 2 | Part 3 | Part 4 | Part 5 | Part 6
 
15-02-26-Golang-InternalsThis series of blog posts is intended for those who are already familiar with the basics of Go and would like to get a deeper insight into its internals. Today’s post is dedicated to the structure of Go source code and some internal details of the Go compiler. After reading this, you should be able to answer the following questions:

1. What is the structure of Go source code?
2. How does the Go compiler work?
3. What is the basic structure of a node tree in Go?

(more…)

4 Comments

Performance Benchmark: Redis Cloud vs. ElastiCache vs. openredis vs. RedisGreen vs. Redis To Go

Vladimir Starostenkov

redis database logoIn most performance comparisons, Redis (an open source key-value cache/store) is mainly treated as a caching-only solution. Others are only focused on a single provider. However, customers are interested in deeper utilization of built-in data types and server-side operations. In production, you may have several loads that query your database simultaneously—with different types of tasks.

For this reason, we designed a scenario that evaluates Redis performance in more complicated conditions. It combines two different types of queries (both simple and complex) generated concurrently. We’ve just published the performance results here (latencies, throughput, etc.). In this blog post, you’ll find some of the main findings.

(more…)

No Comments

NoSQL Tech Comparison 2014: Cassandra (DataStax), MongoDB, and Couchbase

Alex Khizhniak

Introducing a NoSQL scoring framework

Even if you have years of experience with data-intensive apps, selecting a NoSQL data store for a particular case out of dozens of options may be a daunting task. The variety of databases goes way beyond sheer numbers, so you have to carefully compare and benchmark several options before you can choose the most appropriate solution.

To help companies select the best database based on particular use cases, workloads, or requirements, we decided to come up with a handy template for evaluating NoSQL solutions. While many other comparisons focus only on one or two dimensions, we compiled a scoring framework that approaches the databases from 20+ angles (including performance, scalability, availability, ease of installation, maintenance, data consistency, fault tolerance, replication, recovery, etc.).

As a real-life example of such an evaluation benchmark, today we present “The NoSQL Technical Comparison Report,” which provides an in-depth analysis of the leading NoSQL systems: Cassandra (DataStax), MongoDB, and Couchbase Server. Each of the databases was scored on a scale from 1 to 10 across 21 criteria.

With 29 charts and 30 tables, this paper features a scoring template for evaluating and comparing NoSQL data stores for your particular use case—depending on the weight of each criterion. We also give recommendations on the best ways to configure, install, and use NoSQL databases depending on their specific features.

 

Want details? Watch a webinar!

(more…)

No Comments

Next Page »

Benchmarks and Research

Subscribe to new posts

Get new posts right in your inbox!