Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Component diagram examples

Component diagrams from several domains, grouped by domain. Each model is illustrative. For the notation, see Component diagrams and the component elements.

Systems software

Monolithic kernel

diagram component "Kernel subsystems"
direction down

component "System Call Interface" as sci

package "Core" as core {
  component "Process Scheduler" as sched
  component "Memory Manager" as mm
  sched --> mm : page faults
}

package "I/O" as io {
  component VFS
  component "Network Stack" as net
  component "Block Layer" as block
  VFS --> block
}

component "Device Drivers" as drivers

sci --> sched
sci --> VFS
sci --> net
block --> drivers
net --> drivers
Kernel subsystems System Call Interface Core Process Scheduler Memory Manager I/O VFS Network Stack Block Layer Device Drivers page faults

Storage engine

diagram component "LSM storage engine"
direction right

component Client { requires IKeyValue }

component Engine as engine {
  port kv provides IKeyValue
  component "Write Path" as write
  component "Read Path" as read
  component Memtable
  component "Write-Ahead Log" as wal
  component Compactor

  kv --> write
  kv --> read
  write --> wal : append
  write --> Memtable : insert
  read --> Memtable : probe
}

component "Block Cache" as cache { provides ICache }
component "SSTable Files" as sst <<filesystem>>

engine ..> cache : uses
engine --> sst : flush, read
note wal: Replayed on startup before the engine accepts writes.
LSM storage engine Client Engine Write Path Read Path Memtable Write-Ahead Log Compactor Replayed on startup before the engine accepts writes. Block Cache «filesystem» SSTable Files ICache IKeyValue kv append insert probe uses flush, read

Hypervisor

diagram component "Type 1 hypervisor"
direction down

package "Guests" as guests {
  component "Linux Guest" as linux { requires IVirtio }
  component "RTOS Guest" as rtos { requires IVirtio }
}

component "Virtual Devices" as vdev {
  provides IVirtio
  requires IDriver
}

package "Hypervisor" as hv {
  component "vCPU Scheduler" as vcpu
  component "Stage-2 MMU" as mmu
  vcpu --> mmu
}

component "Hardware Drivers" as drv { provides IDriver }

guests ..> hv : traps
Type 1 hypervisor Guests Linux Guest RTOS Guest Virtual Devices Hypervisor vCPU Scheduler Stage-2 MMU Hardware Drivers IDriver IVirtio IVirtio traps

Container runtime

diagram component "Container runtime"
direction right

component CLI { requires IRuntimeApi }

component Daemon {
  provides IRuntimeApi
  requires IOci
  requires IImages
}

component "Image Store" as images { provides IImages }

component Shim {
  provides IOci
  requires ISyscalls
}

component "Linux Kernel" as kernel <<platform>> { provides ISyscalls }
note Shim: Outlives the daemon so that containers survive restarts.
Container runtime CLI Daemon Image Store Shim «platform» Linux Kernel Outlives the daemon so that containers survive restarts. IImages IOci IRuntimeApi ISyscalls

Embedded

Motor controller firmware

diagram component "Motor controller firmware"
direction right

package "Application" as app {
  component "Speed Loop" as speed
  component "Fault Monitor" as fault
  fault --> speed : limits
}

package "Drivers" as drivers {
  component PWM { provides IPwm }
  component ADC { provides IAdc }
  component CAN { provides ICan }
}

component "Control Task" as control {
  requires IPwm
  requires IAdc
}

component Telemetry { requires ICan }

speed --> control : setpoint
note control: Runs at 20 kHz in interrupt context.
Motor controller firmware Application Speed Loop Fault Monitor Drivers PWM ADC CAN Control Task Telemetry Runs at 20 kHz in interrupt context. IAdc ICan IPwm limits setpoint

Sensor node

diagram component "Battery sensor node"
direction down

component "Sampling Task" as sampler {
  requires II2c
  provides ISamples
}

component "I2C Driver" as i2c { provides II2c }

component "Radio Task" as radio {
  requires ISamples
  requires IRadio
}

component "LoRa Driver" as lora { provides IRadio }
component "Power Manager" as power

power ..> sampler : wake
power ..> radio : wake
Battery sensor node Sampling Task I2C Driver Radio Task LoRa Driver Power Manager II2c IRadio ISamples wake wake

RTOS layers

diagram component "RTOS layers"
direction down

package "Middleware" as mid {
  component "File System" as fs
  component "TCP/IP" as tcp
}

package "Kernel" as kernel {
  component Tasks
  component Queues
  component Timers
  Tasks --> Queues
  Tasks --> Timers
}

component HAL <<port layer>>

fs --> Tasks
tcp --> Tasks
Queues --> HAL
Timers --> HAL
RTOS layers Middleware File System TCP/IP Kernel Tasks Queues Timers «port layer» HAL

Bootloader

diagram component "Secure boot chain"
direction right

component "ROM" as rom <<immutable>>
component "First Stage" as fsbl
component "Verifier" as verify { provides IVerify }
component "Second Stage" as ssbl { requires IVerify }
component "Kernel Image" as image

rom --> fsbl : verifies
fsbl --> ssbl : loads
ssbl --> image : verifies, starts
note rom: Holds the root public key hash.
Secure boot chain «immutable» ROM First Stage Verifier Second Stage Kernel Image Holds the root public key hash. IVerify verifies loads verifies, starts

Vehicle gateway

diagram component "Vehicle gateway"
direction right

component "Powertrain ECU" as ptrain { port can requires IFrames }
component "Body ECU" as body { port can requires IFrames }

component Gateway {
  port bus provides IFrames
  port uplink requires IEthernet

  component Router
  component Firewall

  bus --> Firewall
  Firewall --> Router
  Router --> uplink
}

component "Telematics Unit" as tcu { provides IEthernet }
Vehicle gateway Powertrain ECU Body ECU Gateway Router Firewall Telematics Unit IEthernet IFrames IFrames can can bus uplink

Compilers and tools

Compiler pipeline

diagram component "Compiler pipeline"
direction down

component Driver { requires ITokens }

package "Front End" as front {
  component Lexer { provides ITokens }
  component Parser
  component "Type Checker" as sema
  Lexer --> Parser : tokens
  Parser --> sema : AST
}

package "Back End" as back {
  component "IR Builder" as ir
  component Optimizer
  component "Code Generator" as codegen { provides ITarget }
  ir --> Optimizer
  Optimizer --> codegen : SSA
}

sema --> ir : typed AST
Driver ..> codegen : invoke
Compiler pipeline Driver Front End Lexer Parser Type Checker Back End IR Builder Optimizer Code Generator ITarget ITokens tokens AST SSA typed AST invoke

Language server

diagram component "Language server"
direction right

component Editor { requires ILsp }

component Server as server {
  port lsp provides ILsp
  component Dispatcher
  component "Incremental Parser" as parser
  component "Symbol Index" as index
  component Diagnostics

  lsp --> Dispatcher
  Dispatcher --> parser : didChange
  parser --> index : update
  parser --> Diagnostics : errors
}

component "File Watcher" as watcher
watcher --> server : changes
Language server Editor Server Dispatcher Incremental Parser Symbol Index Diagnostics File Watcher ILsp lsp didChange update errors changes

Build system

diagram component "Build system"
direction right

component "Build Files" as files <<input>>
component "Graph Builder" as graph
component Scheduler { requires IExecutor, ICache }
component "Local Executor" as local { provides IExecutor }
component "Content Cache" as cache { provides ICache }

files --> graph : parse
graph --> Scheduler : actions
note cache: Keyed by a hash of each action's inputs.
Build system «input» Build Files Graph Builder Scheduler Local Executor Content Cache Keyed by a hash of each action's inputs. ICache IExecutor parse actions

Debugger

diagram component "Debugger"
direction right

component "Debug UI" as ui { requires IDebug }
component Engine {
  provides IDebug
  requires ISymbols
  requires ITarget
}
component "DWARF Reader" as dwarf { provides ISymbols }
component "ptrace Backend" as ptrace { provides ITarget }
Debugger Debug UI Engine DWARF Reader ptrace Backend IDebug ISymbols ITarget

This site’s toolchain

diagram component "Documentation build"
direction right

component "Markdown Chapters" as md <<input>>
component mdBook { requires IPreprocessor }
component "mdbook-drumlin" as pre {
  provides IPreprocessor
  requires IRender
}
component "drumlin library" as lib { provides IRender }
component "Static Site" as site <<output>>

md --> mdBook
mdBook --> site : HTML with inline SVG
Documentation build «input» Markdown Chapters mdBook mdbook-drumlin drumlin library «output» Static Site IPreprocessor IRender HTML with inline SVG

Distributed services

Hexagonal service

diagram component "Hexagonal service"
direction right

component "HTTP Adapter" as http { requires IUseCases }

component Core as core {
  port api provides IUseCases
  port repo requires IRepository
  port publish requires IEvents

  component "Use Cases" as cases
  component "Domain Model" as model

  api --> cases
  cases --> model
  cases --> repo
  cases --> publish
}

component "SQL Adapter" as sql { provides IRepository }
component "Kafka Adapter" as kafka { provides IEvents }
Hexagonal service HTTP Adapter Core Use Cases Domain Model SQL Adapter Kafka Adapter IEvents IRepository IUseCases api repo publish

Consensus group

diagram component "Replicated state machine"
direction right

component Client { requires IPropose }

component Replica as replica {
  port propose provides IPropose
  port peers requires IRaftRpc

  component "Consensus Module" as raft
  component Log
  component "State Machine" as sm

  propose --> raft
  raft --> Log : append
  Log --> sm : apply committed
  raft --> peers
}

component "Peer Replicas" as others { provides IRaftRpc }
Replicated state machine Client Replica Consensus Module Log State Machine Peer Replicas IPropose IRaftRpc propose peers append apply committed

Cache-aside

diagram component "Cache-aside read"
direction right

component Service
component Redis <<cache>>
component Postgres <<database>>

Service --> Redis : 1. get
Service --> Postgres : 2. on miss
Service ..> Redis : 3. set, ttl 60s
Cache-aside read Service «cache» Redis «database» Postgres 1. get 2. on miss 3. set, ttl 60s

API gateway

diagram component "API gateway"
direction right

component "Mobile App" as mobile { requires IPublicApi }
component "Web App" as web { requires IPublicApi }

component Gateway {
  provides IPublicApi
  requires IAuth
  requires ICatalog
  requires ICheckout
}

package "Services" as services {
  component Auth { provides IAuth }
  component Catalog { provides ICatalog }
  component Checkout { provides ICheckout }
}
API gateway Mobile App Web App Gateway Services Auth Catalog Checkout IAuth ICatalog ICheckout IPublicApi IPublicApi

Event-driven checkout

diagram component "Event-driven checkout"
direction right

component Checkout { requires IBus }
component "Message Bus" as bus { provides IBus }
component Payments
component Inventory
component Shipping

bus --> Payments : OrderPlaced
bus --> Inventory : OrderPlaced
Payments --> Shipping : PaymentCaptured
Inventory --> Shipping : StockReserved
note bus: Delivery is at least once. Handlers are idempotent.
Event-driven checkout Checkout Message Bus Payments Inventory Shipping Delivery is at least once. Handlers are idempotent. IBus OrderPlaced OrderPlaced PaymentCaptured StockReserved

Data platforms

ETL pipeline

diagram component "Nightly ETL"
direction right

component "Source Databases" as src <<database>>
component Extract
component Transform
component Load
component Warehouse <<database>>
component "Data Quality" as dq

src --> Extract
Extract --> Transform : parquet
Transform --> Load
Load --> Warehouse
Transform ..> dq : assertions
Nightly ETL «database» Source Databases Extract Transform Load «database» Warehouse Data Quality parquet assertions

Stream processor

diagram component "Stream processor"
direction right

component Producers { requires ILog }
component "Partitioned Log" as log {
  provides ILog
  provides ISubscribe
}

component Job as job {
  port source requires ISubscribe
  component Windowing
  component Aggregator
  component Sink
  source --> Windowing
  Windowing --> Aggregator
  Aggregator --> Sink
}

component "State Backend" as state <<rocksdb>>
job ..> state : checkpoints
Stream processor Producers Partitioned Log Job Windowing Aggregator Sink «rocksdb» State Backend ILog ISubscribe source checkpoints

Query engine

diagram component "Query engine"
direction down

component "SQL Parser" as parser
component Planner { requires ICatalog }
component Catalog { provides ICatalog }
component Optimizer
component Executor
component "Storage Layer" as storage

parser --> Planner : AST
Planner --> Optimizer : logical plan
Optimizer --> Executor : physical plan
Executor --> storage : scans
Query engine SQL Parser Planner Catalog Optimizer Executor Storage Layer ICatalog AST logical plan physical plan scans

ML serving

diagram component "Model serving"
direction right

component Client { requires IPredict }

package "Serving" as serving {
  component Router { provides IPredict }
  component "Model A" as a
  component "Model B" as b
  Router --> a : 95%
  Router --> b : 5%
}

component "Feature Store" as features <<database>>
component "Metrics Sink" as metrics

serving ..> features : lookup
serving ..> metrics : latency
Model serving Client Serving Router Model A Model B «database» Feature Store Metrics Sink IPredict 95% 5% lookup latency