diff --git a/include/maxscale/routingworker.hh b/include/maxscale/routingworker.hh
index bbaa809b8..ec6eaf629 100644
--- a/include/maxscale/routingworker.hh
+++ b/include/maxscale/routingworker.hh
@@ -19,6 +19,7 @@
 #include <mutex>
 #include <type_traits>
 
+#include <maxbase/atomic.hh>
 #include <maxbase/semaphore.hh>
 #include <maxbase/worker.hh>
 #include <maxscale/poll.h>
@@ -336,7 +337,7 @@ public:
     static uint64_t create_key()
     {
         static uint64_t id_generator = 0;
-        return atomic_add_uint64(&id_generator, 1);
+        return mxb::atomic::add(&id_generator, 1, mxb::atomic::RELAXED);
     }
 
     /**
diff --git a/maxutils/maxbase/src/worker.cc b/maxutils/maxbase/src/worker.cc
index 954877ae1..449bf1015 100644
--- a/maxutils/maxbase/src/worker.cc
+++ b/maxutils/maxbase/src/worker.cc
@@ -23,6 +23,7 @@
 #include <sys/timerfd.h>
 
 #include <maxbase/assert.h>
+#include <maxbase/atomic.hh>
 #include <maxbase/log.h>
 #include <maxbase/string.h>
 
@@ -373,8 +374,8 @@ bool Worker::add_fd(int fd, uint32_t events, MXB_POLL_DATA* pData)
 
     if (epoll_ctl(m_epoll_fd, EPOLL_CTL_ADD, fd, &ev) == 0)
     {
-        atomic_add_uint32(&m_nCurrent_descriptors, 1);
-        atomic_add_uint64(&m_nTotal_descriptors, 1);
+        mxb::atomic::add(&m_nCurrent_descriptors, 1, mxb::atomic::RELAXED);
+        mxb::atomic::add(&m_nTotal_descriptors, 1, mxb::atomic::RELAXED);
     }
     else
     {
@@ -393,7 +394,7 @@ bool Worker::remove_fd(int fd)
 
     if (epoll_ctl(m_epoll_fd, EPOLL_CTL_DEL, fd, &ev) == 0)
     {
-        atomic_add_uint32(&m_nCurrent_descriptors, -1);
+        mxb::atomic::add(&m_nCurrent_descriptors, -1, mxb::atomic::RELAXED);
     }
     else
     {
@@ -767,7 +768,7 @@ void Worker::poll_waitevents()
 
         m_state = POLLING;
 
-        atomic_add_int64(&m_statistics.n_polls, 1);
+        atomic::add(&m_statistics.n_polls, 1, atomic::RELAXED);
 
         uint64_t now = Load::get_time();
         int timeout = Load::GRANULARITY - (now - m_load.start_time());
@@ -816,7 +817,7 @@ void Worker::poll_waitevents()
             MXB_DEBUG("%lu [poll_waitevents] epoll_wait found %d fds",
                       pthread_self(),
                       nfds);
-            atomic_add_int64(&m_statistics.n_pollev, 1);
+            mxb::atomic::add(&m_statistics.n_pollev, 1, mxb::atomic::RELAXED);
 
             m_state = PROCESSING;
 
@@ -848,27 +849,27 @@ void Worker::poll_waitevents()
 
             if (actions & MXB_POLL_ACCEPT)
             {
-                atomic_add_int64(&m_statistics.n_accept, 1);
+                mxb::atomic::add(&m_statistics.n_accept, 1, mxb::atomic::RELAXED);
             }
 
             if (actions & MXB_POLL_READ)
             {
-                atomic_add_int64(&m_statistics.n_read, 1);
+                mxb::atomic::add(&m_statistics.n_read, 1, mxb::atomic::RELAXED);
             }
 
             if (actions & MXB_POLL_WRITE)
             {
-                atomic_add_int64(&m_statistics.n_write, 1);
+                mxb::atomic::add(&m_statistics.n_write, 1, mxb::atomic::RELAXED);
             }
 
             if (actions & MXB_POLL_HUP)
             {
-                atomic_add_int64(&m_statistics.n_hup, 1);
+                mxb::atomic::add(&m_statistics.n_hup, 1, mxb::atomic::RELAXED);
             }
 
             if (actions & MXB_POLL_ERROR)
             {
-                atomic_add_int64(&m_statistics.n_error, 1);
+                mxb::atomic::add(&m_statistics.n_error, 1, mxb::atomic::RELAXED);
             }
 
             /** Calculate event execution statistics */
diff --git a/maxutils/maxbase/src/workertask.cc b/maxutils/maxbase/src/workertask.cc
index 8f92a0096..f3b86674c 100644
--- a/maxutils/maxbase/src/workertask.cc
+++ b/maxutils/maxbase/src/workertask.cc
@@ -12,7 +12,7 @@
  */
 
 #include <maxbase/workertask.hh>
-#include <maxbase/atomic.h>
+#include <maxbase/atomic.hh>
 #include <maxbase/assert.h>
 
 namespace maxbase
@@ -39,14 +39,14 @@ WorkerDisposableTask::~WorkerDisposableTask()
 
 void WorkerDisposableTask::inc_ref()
 {
-    atomic_add(&m_count, 1);
+    mxb::atomic::add(&m_count, 1);
 }
 
 void WorkerDisposableTask::dec_ref()
 {
-    mxb_assert(atomic_load_int32(&m_count) > 0);
+    mxb_assert(mxb::atomic::load(&m_count) > 0);
 
-    if (atomic_add(&m_count, -1) == 1)
+    if (mxb::atomic::add(&m_count, -1) == 1)
     {
         delete this;
     }
diff --git a/server/core/backend.cc b/server/core/backend.cc
index 261ef1ded..2d8f93681 100644
--- a/server/core/backend.cc
+++ b/server/core/backend.cc
@@ -15,6 +15,8 @@
 
 #include <sstream>
 
+#include <maxbase/atomic.hh>
+
 #include <maxscale/protocol/mysql.h>
 
 using namespace maxscale;
@@ -66,7 +68,7 @@ void Backend::close(close_type type)
             m_dcb = NULL;
 
             /** decrease server current connection counters */
-            atomic_add(&m_backend->connections, -1);
+            mxb::atomic::add(&m_backend->connections, -1, mxb::atomic::RELAXED);
         }
     }
     else
@@ -150,7 +152,9 @@ void Backend::clear_state(backend_state state)
 {
     if ((state & WAITING_RESULT) && (m_state & WAITING_RESULT))
     {
-        MXB_AT_DEBUG(int prev2 = ) atomic_add(&m_backend->server->stats.n_current_ops, -1);
+        MXB_AT_DEBUG(int prev2 = ) mxb::atomic::add(&m_backend->server->stats.n_current_ops,
+                                                    -1,
+                                                    mxb::atomic::RELAXED);
         mxb_assert(prev2 > 0);
     }
 
@@ -161,7 +165,9 @@ void Backend::set_state(backend_state state)
 {
     if ((state & WAITING_RESULT) && (m_state & WAITING_RESULT) == 0)
     {
-        MXB_AT_DEBUG(int prev2 = ) atomic_add(&m_backend->server->stats.n_current_ops, 1);
+        MXB_AT_DEBUG(int prev2 = ) mxb::atomic::add(&m_backend->server->stats.n_current_ops,
+                                                    1,
+                                                    mxb::atomic::RELAXED);
         mxb_assert(prev2 >= 0);
     }
 
@@ -177,7 +183,7 @@ bool Backend::connect(MXS_SESSION* session, SessionCommandList* sescmd)
     {
         m_closed = false;
         m_state = IN_USE;
-        atomic_add(&m_backend->connections, 1);
+        mxb::atomic::add(&m_backend->connections, 1, mxb::atomic::RELAXED);
         rval = true;
 
         if (sescmd && sescmd->size())
diff --git a/server/core/buffer.cc b/server/core/buffer.cc
index e266c9903..550a593f5 100644
--- a/server/core/buffer.cc
+++ b/server/core/buffer.cc
@@ -18,7 +18,7 @@
 #include <sstream>
 
 #include <maxbase/assert.h>
-#include <maxbase/atomic.h>
+#include <maxbase/atomic.hh>
 #include <maxscale/alloc.h>
 #include <maxscale/hint.h>
 #include <maxscale/log.h>
@@ -239,7 +239,7 @@ static void gwbuf_free_one(GWBUF* buf)
     BUF_PROPERTY* prop;
     buffer_object_t* bo;
 
-    if (atomic_add(&buf->sbuf->refcount, -1) == 1)
+    if (mxb::atomic::add(&buf->sbuf->refcount, -1) == 1)
     {
         bo = buf->sbuf->bufobj;
 
@@ -291,7 +291,7 @@ static GWBUF* gwbuf_clone_one(GWBUF* buf)
         return NULL;
     }
 
-    atomic_add(&buf->sbuf->refcount, 1);
+    mxb::atomic::add(&buf->sbuf->refcount, 1);
     rval->server = buf->server;
     rval->sbuf = buf->sbuf;
     rval->start = buf->start;
@@ -371,7 +371,7 @@ static GWBUF* gwbuf_clone_portion(GWBUF* buf,
     {
         return NULL;
     }
-    atomic_add(&buf->sbuf->refcount, 1);
+    mxb::atomic::add(&buf->sbuf->refcount, 1);
     clonebuf->server = buf->server;
     clonebuf->sbuf = buf->sbuf;
     clonebuf->gwbuf_type = buf->gwbuf_type;     /*< clone info bits too */
diff --git a/server/core/dcb.cc b/server/core/dcb.cc
index 140c33c95..59809eb31 100644
--- a/server/core/dcb.cc
+++ b/server/core/dcb.cc
@@ -40,7 +40,7 @@
 
 #include <maxscale/alloc.h>
 #include <maxbase/atomic.h>
-#include <maxbase/atomic.h>
+#include <maxbase/atomic.hh>
 #include <maxscale/clock.h>
 #include <maxscale/limits.h>
 #include <maxscale/listener.h>
@@ -400,7 +400,7 @@ DCB* dcb_connect(SERVER* server, MXS_SESSION* session, const char* protocol)
             dcb->persistentstart = 0;
             dcb->was_persistent = true;
             dcb->last_read = mxs_clock();
-            atomic_add_uint64(&server->stats.n_from_pool, 1);
+            mxb::atomic::add(&server->stats.n_from_pool, 1, mxb::atomic::RELAXED);
             return dcb;
         }
         else
@@ -533,8 +533,8 @@ DCB* dcb_connect(SERVER* server, MXS_SESSION* session, const char* protocol)
     /**
      * The dcb will be addded into poll set by dcb->func.connect
      */
-    atomic_add(&server->stats.n_connections, 1);
-    atomic_add(&server->stats.n_current, 1);
+    mxb::atomic::add(&server->stats.n_connections, 1, mxb::atomic::RELAXED);
+    mxb::atomic::add(&server->stats.n_current, 1, mxb::atomic::RELAXED);
 
     return dcb;
 }
@@ -1254,7 +1254,7 @@ void dcb_final_close(DCB* dcb)
             // This is now a DCB_ROLE_BACKEND_HANDLER.
             // TODO: Make decisions according to the role and assert
             // TODO: that what the role implies is preset.
-            atomic_add(&dcb->server->stats.n_current, -1);
+            mxb::atomic::add(&dcb->server->stats.n_current, -1, mxb::atomic::RELAXED);
         }
 
         if (dcb->fd > 0)
@@ -1314,7 +1314,7 @@ static bool dcb_maybe_add_persistent(DCB* dcb)
         && !dcb->dcb_errhandle_called
         && !(dcb->flags & DCBF_HUNG)
         && dcb_persistent_clean_count(dcb, owner->id(), false) < dcb->server->persistpoolmax
-        && dcb->server->stats.n_persistent < dcb->server->persistpoolmax)
+        && mxb::atomic::load(&dcb->server->stats.n_persistent) < dcb->server->persistpoolmax)
     {
         DCB_CALLBACK* loopcallback;
         MXS_DEBUG("Adding DCB to persistent pool, user %s.", dcb->user);
@@ -1351,8 +1351,8 @@ static bool dcb_maybe_add_persistent(DCB* dcb)
 
         dcb->nextpersistent = dcb->server->persistent[owner->id()];
         dcb->server->persistent[owner->id()] = dcb;
-        atomic_add(&dcb->server->stats.n_persistent, 1);
-        atomic_add(&dcb->server->stats.n_current, -1);
+        mxb::atomic::add(&dcb->server->stats.n_persistent, 1);
+        mxb::atomic::add(&dcb->server->stats.n_current, -1, mxb::atomic::RELAXED);
         return true;
     }
     else if (dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER && dcb->server)
@@ -2106,7 +2106,7 @@ int dcb_persistent_clean_count(DCB* dcb, int id, bool cleanall)
                 /* Add removed DCBs to disposal list for processing outside spinlock */
                 persistentdcb->nextpersistent = disposals;
                 disposals = persistentdcb;
-                atomic_add(&server->stats.n_persistent, -1);
+                mxb::atomic::add(&server->stats.n_persistent, -1);
             }
             else
             {
@@ -2528,7 +2528,7 @@ DCB* dcb_accept(DCB* dcb)
 
     if (client_dcb)
     {
-        atomic_add(&client_dcb->service->client_count, 1);
+        mxb::atomic::add(&client_dcb->service->client_count, 1);
     }
 
     return client_dcb;
diff --git a/server/core/housekeeper.cc b/server/core/housekeeper.cc
index 57341596e..1f21be3d1 100644
--- a/server/core/housekeeper.cc
+++ b/server/core/housekeeper.cc
@@ -20,7 +20,7 @@
 
 #include <maxbase/semaphore.h>
 #include <maxscale/alloc.h>
-#include <maxbase/atomic.h>
+#include <maxbase/atomic.hh>
 #include <maxscale/clock.h>
 #include <maxscale/config.h>
 #include <maxscale/housekeeper.h>
@@ -57,7 +57,7 @@ static int64_t mxs_clock_ticks = 0;     /*< One clock tick is 100 milliseconds *
 
 int64_t mxs_clock()
 {
-    return atomic_load_int64(&mxs_clock_ticks);
+    return mxb::atomic::load(&mxs_clock_ticks, mxb::atomic::RELAXED);
 }
 
 namespace
@@ -121,7 +121,7 @@ private:
 
     bool is_running() const
     {
-        return atomic_load_uint32(&m_running);
+        return mxb::atomic::load(&m_running);
     }
 };
 
@@ -169,7 +169,7 @@ void Housekeeper::run()
         for (int i = 0; i < 10; i++)
         {
             std::this_thread::sleep_for(std::chrono::milliseconds(100));
-            atomic_add_int64(&mxs_clock_ticks, 1);
+            mxb::atomic::add(&mxs_clock_ticks, 1, mxb::atomic::RELAXED);
         }
 
         mxs::SpinLockGuard guard(m_lock);
@@ -199,7 +199,7 @@ void Housekeeper::stop()
     mxb_assert(hk);                                         // init() has been called.
     mxb_assert(hk->m_thread.get_id() != std::thread::id()); // start has been called.
 
-    atomic_store_uint32(&m_running, 0);
+    mxb::atomic::store(&m_running, 0);
     m_thread.join();
 }
 
diff --git a/server/core/monitor.cc b/server/core/monitor.cc
index f37c5ccdb..84ae4b408 100644
--- a/server/core/monitor.cc
+++ b/server/core/monitor.cc
@@ -28,6 +28,7 @@
 #include <vector>
 
 #include <maxscale/alloc.h>
+#include <maxbase/atomic.hh>
 #include <maxscale/clock.h>
 #include <maxscale/json_api.h>
 #include <maxscale/log.h>
@@ -2937,7 +2938,7 @@ void MonitorInstance::run_one_tick()
     monitor_check_maintenance_requests(m_monitor);
 
     tick();
-    atomic_add_uint64(&m_monitor->ticks, 1);
+    mxb::atomic::add(&m_monitor->ticks, 1, mxb::atomic::RELAXED);
 
     flush_server_status();
 
diff --git a/server/core/routingworker.cc b/server/core/routingworker.cc
index 30916de2f..b013ad4f6 100644
--- a/server/core/routingworker.cc
+++ b/server/core/routingworker.cc
@@ -21,7 +21,7 @@
 #include <vector>
 #include <sstream>
 
-#include <maxbase/atomic.h>
+#include <maxbase/atomic.hh>
 #include <maxbase/semaphore.hh>
 #include <maxscale/alloc.h>
 #include <maxscale/config.h>
@@ -82,7 +82,7 @@ struct this_unit
 
 int next_worker_id()
 {
-    return atomic_add(&this_unit.next_worker_id, 1);
+    return mxb::atomic::add(&this_unit.next_worker_id, 1, mxb::atomic::RELAXED);
 }
 
 thread_local struct this_thread
@@ -961,7 +961,8 @@ std::unique_ptr<json_t> RoutingWorker::get_qc_stats_as_json(const char* zHost)
 RoutingWorker* RoutingWorker::pick_worker()
 {
     static int id_generator = 0;
-    int id = this_unit.id_min_worker + (atomic_add(&id_generator, 1) % this_unit.nWorkers);
+    int id = this_unit.id_min_worker
+        + (mxb::atomic::add(&id_generator, 1, mxb::atomic::RELAXED) % this_unit.nWorkers);
     return get(id);
 }
 }
diff --git a/server/core/server.cc b/server/core/server.cc
index 2e62c166f..d3c65c866 100644
--- a/server/core/server.cc
+++ b/server/core/server.cc
@@ -31,6 +31,7 @@
 #include <sstream>
 #include <mutex>
 
+#include <maxbase/atomic.hh>
 #include <maxbase/stopwatch.hh>
 
 #include <maxscale/config.h>
@@ -284,8 +285,8 @@ DCB* server_get_persistent(SERVER* server, const char* user, const char* ip, con
                 }
                 MXS_FREE(dcb->user);
                 dcb->user = NULL;
-                atomic_add(&server->stats.n_persistent, -1);
-                atomic_add(&server->stats.n_current, 1);
+                mxb::atomic::add(&server->stats.n_persistent, -1);
+                mxb::atomic::add(&server->stats.n_current, 1, mxb::atomic::RELAXED);
                 return dcb;
             }
             else
diff --git a/server/core/service.cc b/server/core/service.cc
index aed19fe63..17073e083 100644
--- a/server/core/service.cc
+++ b/server/core/service.cc
@@ -33,7 +33,9 @@
 #include <vector>
 #include <unordered_set>
 
+#include <maxbase/atomic.hh>
 #include <maxbase/jansson.h>
+
 #include <maxscale/service.h>
 #include <maxscale/alloc.h>
 #include <maxscale/dcb.h>
@@ -258,7 +260,7 @@ Service::~Service()
 
 void service_free(Service* service)
 {
-    mxb_assert(atomic_load_int(&service->client_count) == 0 || maxscale_teardown_in_progress());
+    mxb_assert(mxb::atomic::load(&service->client_count) == 0 || maxscale_teardown_in_progress());
     mxb_assert(!service->active || maxscale_teardown_in_progress());
 
     {
@@ -297,7 +299,7 @@ void service_destroy(Service* service)
                   mxs_strerror(errno));
     }
 
-    if (atomic_load_int(&service->client_count) == 0)
+    if (mxb::atomic::load(&service->client_count) == 0)
     {
         // The service has no active sessions, it can be closed immediately
         service_free(service);
diff --git a/server/core/session.cc b/server/core/session.cc
index 55e2d85c3..1a1562b13 100644
--- a/server/core/session.cc
+++ b/server/core/session.cc
@@ -27,7 +27,7 @@
 #include <sstream>
 
 #include <maxscale/alloc.h>
-#include <maxbase/atomic.h>
+#include <maxbase/atomic.hh>
 #include <maxscale/clock.h>
 #include <maxscale/dcb.h>
 #include <maxscale/housekeeper.h>
@@ -232,8 +232,8 @@ static MXS_SESSION* session_alloc_body(SERVICE* service,
                  session->client_dcb->user,
                  session->client_dcb->remote);
     }
-    atomic_add(&service->stats.n_sessions, 1);
-    atomic_add(&service->stats.n_current, 1);
+    mxb::atomic::add(&service->stats.n_sessions, 1, mxb::atomic::RELAXED);
+    mxb::atomic::add(&service->stats.n_current, 1, mxb::atomic::RELAXED);
 
     // Store the session in the client DCB even if the session creation fails.
     // It will be freed later on when the DCB is closed.
@@ -261,7 +261,7 @@ void session_link_backend_dcb(MXS_SESSION* session, DCB* dcb)
 {
     mxb_assert(dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER);
 
-    atomic_add(&session->refcount, 1);
+    mxb::atomic::add(&session->refcount, 1);
     dcb->session = session;
     dcb->service = session->service;
     /** Move this DCB under the same thread */
@@ -354,9 +354,9 @@ static void session_free(MXS_SESSION* session)
     Service* service = static_cast<Service*>(session->service);
 
     session_final_free(session);
-    bool should_destroy = !atomic_load_int(&service->active);
+    bool should_destroy = !mxb::atomic::load(&service->active);
 
-    if (atomic_add(&service->client_count, -1) && should_destroy)
+    if (mxb::atomic::add(&service->client_count, -1) == 1 && should_destroy)
     {
         // Destroy the service in the main routing worker thread
         mxs::RoutingWorker* main_worker = mxs::RoutingWorker::get(mxs::RoutingWorker::MAIN);
@@ -371,7 +371,7 @@ static void session_final_free(MXS_SESSION* session)
 
     session->state = SESSION_STATE_TO_BE_FREED;
 
-    atomic_add(&session->service->stats.n_current, -1);
+    mxb::atomic::add(&session->service->stats.n_current, -1, mxb::atomic::RELAXED);
 
     if (session->client_dcb)
     {
@@ -800,7 +800,7 @@ MXS_SESSION* session_get_by_id(uint64_t id)
 
 MXS_SESSION* session_get_ref(MXS_SESSION* session)
 {
-    atomic_add(&session->refcount, 1);
+    mxb::atomic::add(&session->refcount, 1);
     return session;
 }
 
@@ -809,7 +809,7 @@ void session_put_ref(MXS_SESSION* session)
     if (session && session->state != SESSION_STATE_DUMMY)
     {
         /** Remove one reference. If there are no references left, free session */
-        if (atomic_add(&session->refcount, -1) == 1)
+        if (mxb::atomic::add(&session->refcount, -1) == 1)
         {
             session_free(session);
         }
@@ -818,7 +818,7 @@ void session_put_ref(MXS_SESSION* session)
 
 uint64_t session_get_next_id()
 {
-    return atomic_add_uint64(&next_session_id, 1);
+    return mxb::atomic::add(&next_session_id, 1, mxb::atomic::RELAXED);
 }
 
 json_t* session_json_data(const Session* session, const char* host)
diff --git a/server/modules/routing/hintrouter/dcb.cc b/server/modules/routing/hintrouter/dcb.cc
index ec76de24d..42be267eb 100644
--- a/server/modules/routing/hintrouter/dcb.cc
+++ b/server/modules/routing/hintrouter/dcb.cc
@@ -12,7 +12,7 @@
  */
 
 #include "dcb.hh"
-#include <maxbase/atomic.h>
+#include <maxbase/atomic.hh>
 #include <maxscale/service.h>
 
 Dcb::Dcb(DCB* pDcb)
@@ -49,7 +49,7 @@ void Dcb::deleter(DCB* dcb)
 
         if (pSref)
         {
-            atomic_add(&pSref->connections, -1);
+            mxb::atomic::add(&pSref->connections, -1);
         }
         dcb_close(dcb);
     }
diff --git a/server/modules/routing/hintrouter/hintrouter.cc b/server/modules/routing/hintrouter/hintrouter.cc
index 505e5c95c..3e7008c69 100644
--- a/server/modules/routing/hintrouter/hintrouter.cc
+++ b/server/modules/routing/hintrouter/hintrouter.cc
@@ -17,6 +17,7 @@
 #include <limits>
 #include <vector>
 
+#include <maxbase/atomic.hh>
 #include <maxscale/log.h>
 #include "dcb.hh"
 
@@ -203,7 +204,7 @@ Dcb HintRouter::connect_to_backend(MXS_SESSION* session,
     if (new_connection)
     {
         HR_DEBUG("Connected.");
-        atomic_add(&sref->connections, 1);
+        mxb::atomic::add(&sref->connections, 1, mxb::atomic::RELAXED);
         new_connection->service = session->service;
 
         result = Dcb(new_connection);
diff --git a/server/modules/routing/readconnroute/readconnroute.cc b/server/modules/routing/readconnroute/readconnroute.cc
index faf351ccf..f6f6f057c 100644
--- a/server/modules/routing/readconnroute/readconnroute.cc
+++ b/server/modules/routing/readconnroute/readconnroute.cc
@@ -81,7 +81,7 @@
 #include <maxscale/alloc.h>
 #include <maxscale/server.hh>
 #include <maxscale/router.h>
-#include <maxbase/atomic.h>
+#include <maxbase/atomic.hh>
 #include <maxscale/spinlock.h>
 #include <maxscale/dcb.h>
 #include <maxscale/modinfo.h>
@@ -440,7 +440,7 @@ static MXS_ROUTER_SESSION* newSession(MXS_ROUTER* instance, MXS_SESSION* session
         return NULL;
     }
 
-    atomic_add(&candidate->connections, 1);
+    mxb::atomic::add(&candidate->connections, 1, mxb::atomic::RELAXED);
 
     inst->stats.n_sessions++;
 
@@ -473,7 +473,9 @@ static void freeSession(MXS_ROUTER* router_instance, MXS_ROUTER_SESSION* router_
     ROUTER_INSTANCE* router = (ROUTER_INSTANCE*) router_instance;
     ROUTER_CLIENT_SES* router_cli_ses = (ROUTER_CLIENT_SES*) router_client_ses;
 
-    MXB_AT_DEBUG(int prev_val = ) atomic_add(&router_cli_ses->backend->connections, -1);
+    MXB_AT_DEBUG(int prev_val = ) mxb::atomic::add(&router_cli_ses->backend->connections,
+                                                   -1,
+                                                   mxb::atomic::RELAXED);
     mxb_assert(prev_val > 0);
 
     MXS_FREE(router_cli_ses);
@@ -612,7 +614,7 @@ static int routeQuery(MXS_ROUTER* instance, MXS_ROUTER_SESSION* router_session,
     inst->stats.n_queries++;
 
     // Due to the streaming nature of readconnroute, this is not accurate
-    atomic_add_uint64(&router_cli_ses->backend->server->stats.packets, 1);
+    mxb::atomic::add(&router_cli_ses->backend->server->stats.packets, 1, mxb::atomic::RELAXED);
 
     /** Dirty read for quick check if router is closed. */
     if (router_cli_ses->rses_closed)
diff --git a/server/modules/routing/readwritesplit/rwsplit_mysql.cc b/server/modules/routing/readwritesplit/rwsplit_mysql.cc
index c1181e4e1..01508b7de 100644
--- a/server/modules/routing/readwritesplit/rwsplit_mysql.cc
+++ b/server/modules/routing/readwritesplit/rwsplit_mysql.cc
@@ -131,7 +131,7 @@ bool RWSplitSession::handle_target_is_all(route_target_t route_target,
     else if (route_session_write(gwbuf_clone(querybuf), packet_type, qtype))
     {
         result = true;
-        atomic_add_uint64(&m_router->stats().n_all, 1);
+        mxb::atomic::add(&m_router->stats().n_all, 1, mxb::atomic::RELAXED);
     }
 
     m_qc.set_large_query(is_large);
diff --git a/server/modules/routing/readwritesplit/rwsplit_route_stmt.cc b/server/modules/routing/readwritesplit/rwsplit_route_stmt.cc
index 2daa98645..5bd369f51 100644
--- a/server/modules/routing/readwritesplit/rwsplit_route_stmt.cc
+++ b/server/modules/routing/readwritesplit/rwsplit_route_stmt.cc
@@ -438,7 +438,7 @@ bool RWSplitSession::route_session_write(GWBUF* querybuf, uint8_t command, uint3
             if (backend->execute_session_command())
             {
                 nsucc += 1;
-                atomic_add_uint64(&backend->server()->stats.packets, 1);
+                mxb::atomic::add(&backend->server()->stats.packets, 1, mxb::atomic::RELAXED);
                 m_router->server_stats(backend->server()).total++;
                 m_router->server_stats(backend->server()).read++;
 
@@ -805,7 +805,7 @@ SRWBackend RWSplitSession::handle_slave_is_target(uint8_t cmd, uint32_t stmt_id)
 
     if (target)
     {
-        atomic_add_uint64(&m_router->stats().n_slave, 1);
+        mxb::atomic::add(&m_router->stats().n_slave, 1, mxb::atomic::RELAXED);
         m_router->server_stats(target->server()).read++;
         mxb_assert(target->in_use() || target->can_connect());
     }
@@ -938,7 +938,7 @@ bool RWSplitSession::handle_master_is_target(SRWBackend* dest)
 
     if (target && target == m_current_master)
     {
-        atomic_add_uint64(&m_router->stats().n_master, 1);
+        mxb::atomic::add(&m_router->stats().n_master, 1, mxb::atomic::RELAXED);
         m_router->server_stats(target->server()).write++;
     }
     else
@@ -1092,8 +1092,8 @@ bool RWSplitSession::handle_got_target(GWBUF* querybuf, SRWBackend& target, bool
             m_current_query.copy_from(querybuf);
         }
 
-        atomic_add_uint64(&m_router->stats().n_queries, 1);
-        atomic_add_uint64(&target->server()->stats.packets, 1);
+        mxb::atomic::add(&m_router->stats().n_queries, 1, mxb::atomic::RELAXED);
+        mxb::atomic::add(&target->server()->stats.packets, 1, mxb::atomic::RELAXED);
         m_router->server_stats(target->server()).total++;
 
         if (!m_qc.large_query())
diff --git a/server/modules/routing/readwritesplit/rwsplitsession.cc b/server/modules/routing/readwritesplit/rwsplitsession.cc
index a0f1f5be4..e0ad131db 100644
--- a/server/modules/routing/readwritesplit/rwsplitsession.cc
+++ b/server/modules/routing/readwritesplit/rwsplitsession.cc
@@ -421,7 +421,7 @@ void RWSplitSession::trx_replay_next_stmt()
     {
         // No more statements to execute
         m_is_replay_active = false;
-        atomic_add_uint64(&m_router->stats().n_trx_replay, 1);
+        mxb::atomic::add(&m_router->stats().n_trx_replay, 1, mxb::atomic::RELAXED);
 
         if (!m_replayed_trx.empty())
         {
diff --git a/server/modules/routing/readwritesplit/rwsplitsession.hh b/server/modules/routing/readwritesplit/rwsplitsession.hh
index bb445914e..e87bf4d4b 100644
--- a/server/modules/routing/readwritesplit/rwsplitsession.hh
+++ b/server/modules/routing/readwritesplit/rwsplitsession.hh
@@ -289,10 +289,11 @@ private:
     {
         if (session_trx_is_ending(m_client->session))
         {
-            atomic_add_uint64(m_qc.is_trx_still_read_only()
-                              ? &m_router->stats().n_ro_trx
-                              : &m_router->stats().n_rw_trx,
-                              1);
+            mxb::atomic::add(m_qc.is_trx_still_read_only()
+                             ? &m_router->stats().n_ro_trx
+                             : &m_router->stats().n_rw_trx,
+                             1,
+                             mxb::atomic::RELAXED);
         }
     }
 };
diff --git a/server/modules/routing/schemarouter/schemaroutersession.cc b/server/modules/routing/schemarouter/schemaroutersession.cc
index d7e2c42d5..5b3d4a35d 100644
--- a/server/modules/routing/schemarouter/schemaroutersession.cc
+++ b/server/modules/routing/schemarouter/schemaroutersession.cc
@@ -17,6 +17,7 @@
 
 #include <inttypes.h>
 
+#include <maxbase/atomic.hh>
 #include <maxscale/alloc.h>
 #include <maxscale/modutil.h>
 #include <maxscale/poll.h>
@@ -81,7 +82,7 @@ SchemaRouterSession::SchemaRouterSession(MXS_SESSION* session,
         m_connect_db = db;
     }
 
-    atomic_add(&m_router->m_stats.sessions, 1);
+    mxb::atomic::add(&m_router->m_stats.sessions, 1);
 }
 
 SchemaRouterSession::~SchemaRouterSession()
@@ -415,8 +416,8 @@ int32_t SchemaRouterSession::routeQuery(GWBUF* pPacket)
             /** Session commands, route to all servers */
             if (route_session_write(pPacket, command))
             {
-                atomic_add(&m_router->m_stats.n_sescmd, 1);
-                atomic_add(&m_router->m_stats.n_queries, 1);
+                mxb::atomic::add(&m_router->m_stats.n_sescmd, 1, mxb::atomic::RELAXED);
+                mxb::atomic::add(&m_router->m_stats.n_queries, 1, mxb::atomic::RELAXED);
                 ret = 1;
             }
         }
@@ -453,16 +454,16 @@ int32_t SchemaRouterSession::routeQuery(GWBUF* pPacket)
         {
             if (handle_statement(pPacket, bref, command, type))
             {
-                atomic_add(&m_router->m_stats.n_sescmd, 1);
-                atomic_add(&m_router->m_stats.n_queries, 1);
+                mxb::atomic::add(&m_router->m_stats.n_sescmd, 1, mxb::atomic::RELAXED);
+                mxb::atomic::add(&m_router->m_stats.n_queries, 1, mxb::atomic::RELAXED);
                 ret = 1;
             }
         }
         else if (bref->write(pPacket))
         {
             /** Add one query response waiter to backend reference */
-            atomic_add(&m_router->m_stats.n_queries, 1);
-            atomic_add_uint64(&bref->server()->stats.packets, 1);
+            mxb::atomic::add(&m_router->m_stats.n_queries, 1, mxb::atomic::RELAXED);
+            mxb::atomic::add(&bref->server()->stats.packets, 1, mxb::atomic::RELAXED);
             ret = 1;
         }
         else
@@ -608,7 +609,7 @@ void SchemaRouterSession::clientReply(GWBUF* pPacket, DCB* pDcb)
         }
         else if (bref->write_stored_command())
         {
-            atomic_add(&m_router->m_stats.n_queries, 1);
+            mxb::atomic::add(&m_router->m_stats.n_queries, 1, mxb::atomic::RELAXED);
         }
     }
 
@@ -750,7 +751,7 @@ bool SchemaRouterSession::route_session_write(GWBUF* querybuf, uint8_t command)
     bool succp = false;
 
     MXS_INFO("Session write, routing to all servers.");
-    atomic_add(&m_stats.longest_sescmd, 1);
+    mxb::atomic::add(&m_stats.longest_sescmd, 1, mxb::atomic::RELAXED);
 
     /** Increment the session command count */
     ++m_sent_sescmd;
@@ -776,7 +777,7 @@ bool SchemaRouterSession::route_session_write(GWBUF* querybuf, uint8_t command)
                 if ((*it)->execute_session_command())
                 {
                     succp = true;
-                    atomic_add_uint64(&(*it)->server()->stats.packets, 1);
+                    mxb::atomic::add(&(*it)->server()->stats.packets, 1, mxb::atomic::RELAXED);
                 }
                 else
                 {
@@ -1640,7 +1641,7 @@ bool SchemaRouterSession::handle_statement(GWBUF* querybuf, SSRBackend& bref, ui
 {
     bool succp = false;
 
-    atomic_add(&m_stats.longest_sescmd, 1);
+    mxb::atomic::add(&m_stats.longest_sescmd, 1, mxb::atomic::RELAXED);
 
     /** Increment the session command count */
     ++m_sent_sescmd;
@@ -1655,7 +1656,7 @@ bool SchemaRouterSession::handle_statement(GWBUF* querybuf, SSRBackend& bref, ui
             if (bref->execute_session_command())
             {
                 succp = true;
-                atomic_add_uint64(&bref->server()->stats.packets, 1);
+                mxb::atomic::add(&bref->server()->stats.packets, 1, mxb::atomic::RELAXED);
             }
             else
             {