Hacker News Reader

Comment by _Codemonkeyism | Hacker News Reader

10x speedup (same algorithms, same architecture) replacing Java with C++ is not possible (~2x at max).

One of the latest benchmarks I've seen is "Comparison of Programming Languages in Economics" [1] for code without any IO just number crunching, has a 1.91 to 2.69 speedup of using C++ compared to Java. So any code involving IO is going to be slower.

Replacing bad Java code with excellent machine aligned C++ a 10x speedup is possible.

[1] https://github.com/jesusfv/Comparison-Programming-Languages-...

View on HN

You are placing way too much weight in microbenchmarks. You simply can't use them to make a sweeping statement like you just did. Writing code that is identical to one another from language to language is not idiomatic and is not representative of how you would write each in a large scale project such as cassandra.

Java has a ton of overhead that C++ doesn't. Each object has metadata which results in more "cold data" in the cache. Each object is a heap allocation (unless you're lucky enough to hit the escape analysis optimization), which again leads to less cache locality because things are distributed around memory. Then there's the garbage collector. Then bounds checking.

1. I don't think that the number crunching paper I've cited is a "microbenchmark".

2. You seem to have missed the "bad Java" part, and my reply to Mechanical Sympathy.

It doesn't come from the choice of language. It comes from the choice of architecture. C++ is a tiny piece of the puzzle. It would have been hell to implement such an architecture in Java bit this is as far as the language matters.

It's particularly flawed given:

a) IO is such a large portion of the problem b) Hypertable isn't just way, way faster.

Are there any recent comparative benchmarks of hypertable? I looked around but couldn't find any.

Not that I know of. Anecdotally though, it has some advantages, but doesn't exactly crush the competition.

"a) IO is such a large portion of the problem"

I'm very interested in a cluster benchmark therefor, say 10 servers, as Cassandra claims to scale very well. With a cluster IO has a higher performance impact than one server with local RAID IO.

The way ScyllaDB works, it'd be really weird if it didn't scale at least as well as Cassandra.

IO is not only a large part. It is the main part. That is why it is important to get it right : scylla for instance does not leave the cache to the OS. It has its own caches for everything. Never blocks on IO or page faults because all IO bypasses the kernel. And those are just two tiny examples.

> scylla for instance does not leave the cache to the OS. It has its own caches for everything

Uh-huh... that's all pretty common for databases. Cassandra would fit that description.

> Never blocks on IO or page faults because all IO bypasses the kernel.

That just seems nonsensical. Sometimes, you are waiting for IO. That's just reality. It is conceivable you bypass the kernel for I/O, but that creates a lot of complexity and limitations. Near as I can tell though, they do talk to the kernel for IO.

http://www.scylladb.com/technology/memory/

By the way, I think you're replying to one of the devs of Scylla.

I'm sure I am.

So, in general, I understand there is lots of stuff going on in Scylla that does distinguish it, at least from Cassandra. There is the user space networking logic for IO. However, a lot of the IO overhead with disk, for example.

>However, a lot of the IO overhead with disk, for example.

That's why they benchmarked this workload on a 4x SSD RAID configuration :). Given that i/o bandwidth and throughput continues to increase, processor frequency isn't, and core counts are going up, it's prudent to design a system that can take advantage of this.

Yeah, and a 4x SSD RAID configuration is kind of overkill in the extreme for most Cassandra set ups.

I'm sure there is a way to set up IO subsystems so that Cassandra becomes a huge bottleneck, but that's a pretty specialized context.

Cassandra has a row cache that it does not necessarily use. Most of its data sits in the linux page cache. Because the SSTables are mmaped into memory, you can't get rid of that: even if you do use the row cache, you would be at best using twice as much cache memory.

Scylla never touches the page cache. All IO in seastar is direct IO and then scylla caches everything itself. We always know when the disk access is going to happen. The OS paging mechanism does not do a thing.

As for waiting for IO, of course IO does not complete immediately. But you can either block and wait for it, as Cassandra does (it doesn't even have the option not to in the case of the mmaped regions) or you can do something fully async like seastar that guarantees you never block waiting for IO.

Even on the networking side, you can see from projects like this that you can get what should be enough messaging performance for any NoSQL store out of Java: https://github.com/real-logic/Aeron

Their Java throughput is about 70% of their C++11 throughput, and that's with a pretty synthetic benchmark where there is not any logic behind those messages. Once you add in some real logic there, it gets even thinner.

They aren't doing user space networking, but that actually ought to allow Java to do even better.

[Edit: The LMAX guys showed how much more performance is possible with aligning code with CPU/hardware (in this case for Java)

http://mechanical-sympathy.blogspot.de/ ]

That's at a microbenchmark, cpu bound level. You usually aren't at that point.

Reply on news.ycombinator.com