Shared Nothing Architecture

Shared Nothing Architecture Definition

In distributed computing, a shared-nothing architecture consists of multiple nodes that do not share resources (e.g., memory, CPU, and NIC buffer queues). Requests are serviced by a single node, avoiding contention among nodes.

This image depicts shared nothing architecture, consisting of multiple nodes that do not share resources and is compared to a traditional stack.

Shared Nothing Architecture FAQs

What is Shared Nothing Architecture?

Computer scientist Michael Stonebraker first introduced the “shared-nothing architecture” term in his 1986 paper “The Case for Shared Nothing”:

“The three most commonly mentioned architectures for multiprocessor high transaction rate systems are:

  • shared memory (SM), i.e. multiple processors shared a common central memory
  • shared disk (SD), i.e. multiple processors each with private memory share a common collection of disks
  • shared nothing (SN), i.e. neither memory nor peripheral storage is shared among processors”

What is the Advantage of Shared Nothing Architecture?

Shared nothing architecture provides low latency, high bandwidth, as well as high availability.

What are the Disadvantages of Shared Nothing Architecture?

In his paper “The Case for Shared Nothing,” computer scientist Michael Stonebraker found that “shared nothing systems had no no apparent disadvantages compared to the other alternatives.” Others have cited that it increases the complexity of development for those building applications with a shared-nothing architecture.

What is an Example of Shared Nothing Architecture?

Seastar, asynchronous programming framework used by projects like Ceph, Redpanda, and ScyllaDB, uses a shared-nothing model that shards all requests onto individual cores.

Seastar runs one application thread per core, and depends on explicit message passing, not shared memory between threads. This design avoids slow, unscalable lock primitives and cache bounces.

Any sharing of resources across cores must be handled explicitly. For example, when two requests are part of the same session, and two CPUs each get a request that depends on the same session state, one CPU must explicitly forward the request to the other. Either CPU may handle either response. Seastar provides facilities that limit the need for cross-core communication, but when communication is inevitable, it provides high performance non-blocking communication primitives to ensure performance is not degraded.

Other examples of shared nothing architecture include Teradata, OpenStack, and Exasol.

Does ScyllaDB Use a Shared-Nothing Architecture?

Yes, ScyllaDB uses a highly asynchronous, shared-nothing architecture for its database, based on its underlying Seastar framework. Each shard of data is allotted CPU, RAM, persistent storage and networking resources which it uses as efficiently as possible. With its own custom schedulers for CPU and I/O processing, ScyllaDB extracts maximum efficiency out of modern cloud infrastructure.

Where Can I Learn More About Shared-Nothing Architecture?

Here are some top shared-nothing architecture resources:

Trending NoSQL Resources

ScyllaDB University Mascot

ScyllaDB University

Get started on your path to becoming a ScyllaDB expert.