SERVER-36644 remove AtomicWord typedefs

136 files changed, 316 insertions, 319 deletions

diff --git a/src/mongo/base/counter.h b/src/mongo/base/counter.h
index c7ada029928..c26f4444b6a 100644
--- a/src/mongo/base/counter.h
+++ b/src/mongo/base/counter.h
@@ -64,6 +64,6 @@ public:
     }
 
 private:
-    AtomicInt64 _counter;
+    AtomicWord<long long> _counter;
 };
 }  // namespace mongo
diff --git a/src/mongo/base/status-inl.h b/src/mongo/base/status-inl.h
index 48204488eb4..b106456fa77 100644
--- a/src/mongo/base/status-inl.h
+++ b/src/mongo/base/status-inl.h
@@ -74,7 +74,7 @@ inline std::string Status::codeString() const {
     return ErrorCodes::errorString(code());
 }
 
-inline AtomicUInt32::WordType Status::refCount() const {
+inline unsigned Status::refCount() const {
     return _error ? _error->refs.load() : 0;
 }
 
diff --git a/src/mongo/base/status.h b/src/mongo/base/status.h
index 04792f49396..be00e68997e 100644
--- a/src/mongo/base/status.h
+++ b/src/mongo/base/status.h
@@ -227,7 +227,7 @@ public:
     // Below interface used for testing code only.
     //
 
-    inline AtomicUInt32::WordType refCount() const;
+    inline unsigned refCount() const;
 
 private:
     // Private since it could result in a type mismatch between code and extraInfo.
@@ -237,7 +237,7 @@ private:
     inline Status();
 
     struct ErrorInfo {
-        AtomicUInt32 refs;             // reference counter
+        AtomicWord<unsigned> refs;     // reference counter
         const ErrorCodes::Error code;  // error code
         const std::string reason;      // description of error cause
         const std::shared_ptr<const ErrorExtraInfo> extra;
diff --git a/src/mongo/bson/oid.cpp b/src/mongo/bson/oid.cpp
index b309f59639c..b55f818b729 100644
--- a/src/mongo/bson/oid.cpp
+++ b/src/mongo/bson/oid.cpp
@@ -36,6 +36,7 @@
 
 #include <boost/functional/hash.hpp>
 #include <limits>
+#include <memory>
 
 #include "mongo/base/init.h"
 #include "mongo/bson/bsonobjbuilder.h"
@@ -46,7 +47,7 @@
 namespace mongo {
 
 namespace {
-std::unique_ptr<AtomicUInt32> counter;
+std::unique_ptr<AtomicWord<int64_t>> counter;
 
 const std::size_t kTimestampOffset = 0;
 const std::size_t kInstanceUniqueOffset = kTimestampOffset + OID::kTimestampSize;
@@ -57,7 +58,7 @@ OID::InstanceUnique _instanceUnique;
 MONGO_INITIALIZER_GENERAL(OIDGeneration, MONGO_NO_PREREQUISITES, ("default"))
 (InitializerContext* context) {
     std::unique_ptr<SecureRandom> entropy(SecureRandom::create());
-    counter.reset(new AtomicUInt32(uint32_t(entropy->nextInt64())));
+    counter = std::make_unique<AtomicWord<int64_t>>(entropy->nextInt64());
     _instanceUnique = OID::InstanceUnique::generate(*entropy);
     return Status::OK();
 }
diff --git a/src/mongo/client/connpool.cpp b/src/mongo/client/connpool.cpp
index 56b6a85edfc..230ea33e049 100644
--- a/src/mongo/client/connpool.cpp
+++ b/src/mongo/client/connpool.cpp
@@ -674,7 +674,7 @@ void ScopedDbConnection::clearPool() {
     globalConnPool.clear();
 }
 
-AtomicInt32 AScopedConnection::_numConnections;
+AtomicWord<int> AScopedConnection::_numConnections;
 
 MONGO_INITIALIZER(SetupDBClientBaseWithConnection)(InitializerContext*) {
     DBClientBase::withConnection_do_not_use = [](std::string host,
diff --git a/src/mongo/client/connpool.h b/src/mongo/client/connpool.h
index c10cf59c9b8..bea0d840029 100644
--- a/src/mongo/client/connpool.h
+++ b/src/mongo/client/connpool.h
@@ -441,7 +441,7 @@ public:
     }
 
 private:
-    static AtomicInt32 _numConnections;
+    static AtomicWord<int> _numConnections;
 };
 
 /** Use to get a connection from the pool.  On exceptions things
diff --git a/src/mongo/client/dbclient_base.cpp b/src/mongo/client/dbclient_base.cpp
index b74f1fe9ec1..bd94e397811 100644
--- a/src/mongo/client/dbclient_base.cpp
+++ b/src/mongo/client/dbclient_base.cpp
@@ -101,7 +101,7 @@ SSLManagerInterface* sslManager() {
 
 }  // namespace
 
-AtomicInt64 DBClientBase::ConnectionIdSequence;
+AtomicWord<long long> DBClientBase::ConnectionIdSequence;
 
 void (*DBClientBase::withConnection_do_not_use)(std::string host,
                                                 std::function<void(DBClientBase*)>) = nullptr;
diff --git a/src/mongo/client/dbclient_base.h b/src/mongo/client/dbclient_base.h
index 6f0458e95ee..f8aa0a41ff6 100644
--- a/src/mongo/client/dbclient_base.h
+++ b/src/mongo/client/dbclient_base.h
@@ -710,7 +710,7 @@ protected:
     /** controls how chatty the client is about network errors & such.  See log.h */
     const logger::LogSeverity _logLevel;
 
-    static AtomicInt64 ConnectionIdSequence;
+    static AtomicWord<long long> ConnectionIdSequence;
     long long _connectionId;  // unique connection id for this connection
 
 private:
diff --git a/src/mongo/client/dbclient_connection.cpp b/src/mongo/client/dbclient_connection.cpp
index c494e7b6d51..51940bd819a 100644
--- a/src/mongo/client/dbclient_connection.cpp
+++ b/src/mongo/client/dbclient_connection.cpp
@@ -666,6 +666,6 @@ void DBClientConnection::handleNotMasterResponse(const BSONObj& replyBody,
     _markFailed(kSetFlag);
 }
 
-AtomicInt32 DBClientConnection::_numConnections;
+AtomicWord<int> DBClientConnection::_numConnections;
 
 }  // namespace mongo
diff --git a/src/mongo/client/dbclient_connection.h b/src/mongo/client/dbclient_connection.h
index ddadf5c0230..d7d58150257 100644
--- a/src/mongo/client/dbclient_connection.h
+++ b/src/mongo/client/dbclient_connection.h
@@ -301,8 +301,8 @@ protected:
     uint64_t _sessionCreationMicros = INVALID_SOCK_CREATION_TIME;
     Date_t _lastConnectivityCheck;
 
-    AtomicBool _stayFailed{false};
-    AtomicBool _failed{false};
+    AtomicWord<bool> _stayFailed{false};
+    AtomicWord<bool> _failed{false};
     const bool autoReconnect;
     Backoff autoReconnectBackoff;
 
@@ -315,7 +315,7 @@ protected:
     bool _internalAuthOnReconnect = false;
     std::map<std::string, BSONObj> authCache;
 
-    static AtomicInt32 _numConnections;
+    static AtomicWord<int> _numConnections;
 
 private:
     /**
diff --git a/src/mongo/client/replica_set_monitor.cpp b/src/mongo/client/replica_set_monitor.cpp
index d78adff5a50..41c59fa9800 100644
--- a/src/mongo/client/replica_set_monitor.cpp
+++ b/src/mongo/client/replica_set_monitor.cpp
@@ -94,7 +94,7 @@ const int64_t unknownLatency = numeric_limits<int64_t>::max();
 
 const ReadPreferenceSetting kPrimaryOnlyReadPreference(ReadPreference::PrimaryOnly, TagSet());
 const Milliseconds kExpeditedRefreshPeriod(500);
-AtomicBool areRefreshRetriesDisabledForTest{false};  // Only true in tests.
+AtomicWord<bool> areRefreshRetriesDisabledForTest{false};  // Only true in tests.
 
 // TODO: Move to ReplicaSetMonitorManager
 ReplicaSetMonitor::ConfigChangeHook asyncConfigChangeHook;
diff --git a/src/mongo/client/replica_set_monitor.h b/src/mongo/client/replica_set_monitor.h
index 669e3de777e..ecfe03388a5 100644
--- a/src/mongo/client/replica_set_monitor.h
+++ b/src/mongo/client/replica_set_monitor.h
@@ -295,7 +295,7 @@ private:
     executor::TaskExecutor::CallbackHandle _refresherHandle;
 
     const SetStatePtr _state;
-    AtomicBool _isRemovedFromManager{false};
+    AtomicWord<bool> _isRemovedFromManager{false};
 };
 
 
diff --git a/src/mongo/db/auth/authorization_manager_impl.h b/src/mongo/db/auth/authorization_manager_impl.h
index a734a1301b8..c3e68183c25 100644
--- a/src/mongo/db/auth/authorization_manager_impl.h
+++ b/src/mongo/db/auth/authorization_manager_impl.h
@@ -203,7 +203,7 @@ private:
     /**
      * A cache of whether there are any users set up for the cluster.
      */
-    AtomicBool _privilegeDocsExist;
+    AtomicWord<bool> _privilegeDocsExist;
 
     std::unique_ptr<AuthzManagerExternalState> _externalState;
 
@@ -256,7 +256,7 @@ private:
      */
     stdx::condition_variable _fetchPhaseIsReady;
 
-    AtomicBool _inUserManagementCommand{false};
+    AtomicWord<bool> _inUserManagementCommand{false};
 };
 
 extern int authorizationManagerCacheSize;
diff --git a/src/mongo/db/auth/sasl_options.cpp b/src/mongo/db/auth/sasl_options.cpp
index 8a8597304b3..ab6152d7556 100644
--- a/src/mongo/db/auth/sasl_options.cpp
+++ b/src/mongo/db/auth/sasl_options.cpp
@@ -210,7 +210,7 @@ ExportedServerParameter<std::string, ServerParameterType::kStartupOnly> SASLAuth
 class ExportedScramIterationCountParameter
     : public ExportedServerParameter<int, ServerParameterType::kStartupAndRuntime> {
 public:
-    ExportedScramIterationCountParameter(StringData name, AtomicInt32* value, int minimum)
+    ExportedScramIterationCountParameter(StringData name, AtomicWord<int>* value, int minimum)
         : ExportedServerParameter<int, ServerParameterType::kStartupAndRuntime>(
               ServerParameterSet::getGlobal(), name.toString(), value),
           _minimum(minimum) {}
diff --git a/src/mongo/db/auth/sasl_options.h b/src/mongo/db/auth/sasl_options.h
index c88da92b615..b9df88e04cf 100644
--- a/src/mongo/db/auth/sasl_options.h
+++ b/src/mongo/db/auth/sasl_options.h
@@ -51,9 +51,9 @@ struct SASLGlobalParams {
     std::string hostName;
     std::string serviceName;
     std::string authdPath;
-    AtomicInt32 scramSHA1IterationCount;
-    AtomicInt32 scramSHA256IterationCount;
-    AtomicInt32 authFailedDelay;
+    AtomicWord<int> scramSHA1IterationCount;
+    AtomicWord<int> scramSHA256IterationCount;
+    AtomicWord<int> authFailedDelay;
 
     SASLGlobalParams();
 };
diff --git a/src/mongo/db/auth/user.h b/src/mongo/db/auth/user.h
index c77b3e551df..c96a03ed5c4 100644
--- a/src/mongo/db/auth/user.h
+++ b/src/mongo/db/auth/user.h
@@ -252,7 +252,7 @@ private:
     RestrictionDocuments _restrictions;
 
     // Indicates whether the user has been marked as invalid by the AuthorizationManager.
-    AtomicBool _isValid{true};
+    AtomicWord<bool> _isValid{true};
 };
 
 using UserHandle = std::shared_ptr<User>;
diff --git a/src/mongo/db/auth/user_cache_invalidator_job_parameters.idl b/src/mongo/db/auth/user_cache_invalidator_job_parameters.idl
index 3f662facedb..19a37d19d5f 100644
--- a/src/mongo/db/auth/user_cache_invalidator_job_parameters.idl
+++ b/src/mongo/db/auth/user_cache_invalidator_job_parameters.idl
@@ -40,7 +40,7 @@ server_parameters:
       checks to determine whether the in-memory cache of user objects has stale data, and if so,
       clears the cache. If there are no changes to user objects, mongos will not clear the cache.
     cpp_varname: userCacheInvalidationIntervalSecs
-    cpp_vartype: AtomicInt32
+    cpp_vartype: AtomicWord<int>
     set_at:
       - startup
       - runtime
diff --git a/src/mongo/db/catalog/multi_index_block.idl b/src/mongo/db/catalog/multi_index_block.idl
index 14c5e3bf696..3d1d4a145d7 100644
--- a/src/mongo/db/catalog/multi_index_block.idl
+++ b/src/mongo/db/catalog/multi_index_block.idl
@@ -39,7 +39,7 @@ server_parameters:
       - runtime
       - startup
     cpp_varname: useReadOnceCursorsForIndexBuilds
-    cpp_vartype: AtomicBool
+    cpp_vartype: AtomicWord<bool>
     default: true
 
   maxIndexBuildMemoryUsageMegabytes:
@@ -48,7 +48,7 @@ server_parameters:
       - runtime
       - startup
     cpp_varname: maxIndexBuildMemoryUsageMegabytes
-    cpp_vartype: AtomicInt32
+    cpp_vartype: AtomicWord<int>
     default: 500
     validator:
       gte: 100
diff --git a/src/mongo/db/catalog/util/partitioned_test.cpp b/src/mongo/db/catalog/util/partitioned_test.cpp
index f7eb220f37c..1bffbf7c201 100644
--- a/src/mongo/db/catalog/util/partitioned_test.cpp
+++ b/src/mongo/db/catalog/util/partitioned_test.cpp
@@ -235,7 +235,7 @@ TEST(PartitionedConcurrency, ShouldProtectConcurrentAccesses) {
     std::vector<stdx::thread> threads;
     const size_t opsPerThread = 1000;
 
-    AtomicUInt32 ready{0};
+    AtomicWord<unsigned> ready{0};
     for (size_t threadId = 1; threadId <= numThreads; ++threadId) {
         auto workerThreadBody = [&, threadId, opsPerThread]() {
 
diff --git a/src/mongo/db/collection_index_usage_tracker.h b/src/mongo/db/collection_index_usage_tracker.h
index c5d15769f5f..6a784ec8bd7 100644
--- a/src/mongo/db/collection_index_usage_tracker.h
+++ b/src/mongo/db/collection_index_usage_tracker.h
@@ -70,7 +70,7 @@ public:
         }
 
         // Number of operations that have used this index.
-        AtomicInt64 accesses;
+        AtomicWord<long long> accesses;
 
         // Date/Time that we started tracking index usage.
         Date_t trackerStartTime;
diff --git a/src/mongo/db/commands/mr.cpp b/src/mongo/db/commands/mr.cpp
index a5008110e29..23c7261d18d 100644
--- a/src/mongo/db/commands/mr.cpp
+++ b/src/mongo/db/commands/mr.cpp
@@ -165,7 +165,7 @@ void assertCollectionNotNull(const NamespaceString& nss, AutoT& autoT) {
 
 }  // namespace
 
-AtomicUInt32 Config::JOB_NUMBER;
+AtomicWord<unsigned> Config::JOB_NUMBER;
 
 JSFunction::JSFunction(const std::string& type, const BSONElement& e) {
     _type = type;
diff --git a/src/mongo/db/commands/mr.h b/src/mongo/db/commands/mr.h
index 20c5bec2173..13fd4a43cd6 100644
--- a/src/mongo/db/commands/mr.h
+++ b/src/mongo/db/commands/mr.h
@@ -250,7 +250,7 @@ public:
     // if the output collection is sharded, we must be told what UUID to use for it
     boost::optional<UUID> finalOutputCollUUID;
 
-    static AtomicUInt32 JOB_NUMBER;
+    static AtomicWord<unsigned> JOB_NUMBER;
 };  // end MRsetup
 
 /**
diff --git a/src/mongo/db/concurrency/d_concurrency_test.cpp b/src/mongo/db/concurrency/d_concurrency_test.cpp
index b3604fe8f55..8723904ba81 100644
--- a/src/mongo/db/concurrency/d_concurrency_test.cpp
+++ b/src/mongo/db/concurrency/d_concurrency_test.cpp
@@ -188,7 +188,7 @@ TEST_F(DConcurrencyTestFixture, ResourceMutex) {
         void waitFor(int n) {
             waitFor([this, n]() { return this->step.load() == n; });
         }
-        AtomicInt32 step{0};
+        AtomicWord<int> step{0};
     } state;
 
     stdx::thread t1([&]() {
@@ -1127,7 +1127,7 @@ TEST_F(DConcurrencyTestFixture, Stress) {
     std::vector<std::pair<ServiceContext::UniqueClient, ServiceContext::UniqueOperationContext>>
         clients = makeKClientsWithLockers(kMaxStressThreads);
 
-    AtomicInt32 ready{0};
+    AtomicWord<int> ready{0};
     std::vector<stdx::thread> threads;
 
 
@@ -1251,7 +1251,7 @@ TEST_F(DConcurrencyTestFixture, StressPartitioned) {
     std::vector<std::pair<ServiceContext::UniqueClient, ServiceContext::UniqueOperationContext>>
         clients = makeKClientsWithLockers(kMaxStressThreads);
 
-    AtomicInt32 ready{0};
+    AtomicWord<int> ready{0};
     std::vector<stdx::thread> threads;
 
     for (int threadId = 0; threadId < kMaxStressThreads; threadId++) {
@@ -1753,8 +1753,8 @@ TEST_F(DConcurrencyTestFixture, CompatibleFirstWithXSXIXIS) {
 TEST_F(DConcurrencyTestFixture, CompatibleFirstStress) {
     int numThreads = 8;
     int testMicros = 500'000;
-    AtomicUInt64 readOnlyInterval{0};
-    AtomicBool done{false};
+    AtomicWord<unsigned long long> readOnlyInterval{0};
+    AtomicWord<bool> done{false};
     std::vector<uint64_t> acquisitionCount(numThreads);
     std::vector<uint64_t> timeoutCount(numThreads);
     std::vector<uint64_t> busyWaitCount(numThreads);
diff --git a/src/mongo/db/concurrency/lock_state.cpp b/src/mongo/db/concurrency/lock_state.cpp
index 8b3c8cf7abc..8ffbee8c523 100644
--- a/src/mongo/db/concurrency/lock_state.cpp
+++ b/src/mongo/db/concurrency/lock_state.cpp
@@ -112,7 +112,7 @@ const ResourceId resourceIdGlobal = ResourceId(RESOURCE_GLOBAL, ResourceId::SING
 const Milliseconds MaxWaitTime = Milliseconds(500);
 
 // Dispenses unique LockerId identifiers
-AtomicUInt64 idCounter(0);
+AtomicWord<unsigned long long> idCounter(0);
 
 // Partitioned global lock statistics, so we don't hit the same bucket
 PartitionedInstanceWideLockStats globalStats;
diff --git a/src/mongo/db/concurrency/lock_stats.cpp b/src/mongo/db/concurrency/lock_stats.cpp
index b4e1105c081..8a3410fc6ef 100644
--- a/src/mongo/db/concurrency/lock_stats.cpp
+++ b/src/mongo/db/concurrency/lock_stats.cpp
@@ -131,8 +131,8 @@ void LockStats<CounterType>::reset() {
 }
 
 
-// Ensures that there are instances compiled for LockStats for AtomicInt64 and int64_t
+// Ensures that there are instances compiled for LockStats for AtomicWord<long long> and int64_t
 template class LockStats<int64_t>;
-template class LockStats<AtomicInt64>;
+template class LockStats<AtomicWord<long long>>;
 
 }  // namespace mongo
diff --git a/src/mongo/db/concurrency/lock_stats.h b/src/mongo/db/concurrency/lock_stats.h
index 6add6cfefa6..188b92565d2 100644
--- a/src/mongo/db/concurrency/lock_stats.h
+++ b/src/mongo/db/concurrency/lock_stats.h
@@ -46,7 +46,7 @@ struct CounterOps {
         return counter;
     }
 
-    static int64_t get(const AtomicInt64& counter) {
+    static int64_t get(const AtomicWord<long long>& counter) {
         return counter.load();
     }
 
@@ -54,7 +54,7 @@ struct CounterOps {
         counter = value;
     }
 
-    static void set(AtomicInt64& counter, int64_t value) {
+    static void set(AtomicWord<long long>& counter, int64_t value) {
         counter.store(value);
     }
 
@@ -62,11 +62,11 @@ struct CounterOps {
         counter += value;
     }
 
-    static void add(int64_t& counter, const AtomicInt64& value) {
+    static void add(int64_t& counter, const AtomicWord<long long>& value) {
         counter += value.load();
     }
 
-    static void add(AtomicInt64& counter, int64_t value) {
+    static void add(AtomicWord<long long>& counter, int64_t value) {
         counter.addAndFetch(value);
     }
 };
@@ -208,7 +208,7 @@ private:
 };
 
 typedef LockStats<int64_t> SingleThreadedLockStats;
-typedef LockStats<AtomicInt64> AtomicLockStats;
+typedef LockStats<AtomicWord<long long>> AtomicLockStats;
 
 
 /**
diff --git a/src/mongo/db/concurrency/write_conflict_exception.cpp b/src/mongo/db/concurrency/write_conflict_exception.cpp
index 7be5003291f..3885f6491f5 100644
--- a/src/mongo/db/concurrency/write_conflict_exception.cpp
+++ b/src/mongo/db/concurrency/write_conflict_exception.cpp
@@ -40,7 +40,7 @@
 
 namespace mongo {
 
-AtomicBool WriteConflictException::trace(false);
+AtomicWord<bool> WriteConflictException::trace(false);
 
 WriteConflictException::WriteConflictException()
     : DBException(Status(ErrorCodes::WriteConflict, "WriteConflict")) {
diff --git a/src/mongo/db/concurrency/write_conflict_exception.h b/src/mongo/db/concurrency/write_conflict_exception.h
index 9e8c4c4fcbf..e0844cb7ae7 100644
--- a/src/mongo/db/concurrency/write_conflict_exception.h
+++ b/src/mongo/db/concurrency/write_conflict_exception.h
@@ -61,7 +61,7 @@ public:
      * If true, will call printStackTrace on every WriteConflictException created.
      * Can be set via setParameter named traceWriteConflictExceptions.
      */
-    static AtomicBool trace;
+    static AtomicWord<bool> trace;
 
 private:
     void defineOnlyInFinalSubclassToPreventSlicing() final {}
diff --git a/src/mongo/db/free_mon/free_mon_controller_test.cpp b/src/mongo/db/free_mon/free_mon_controller_test.cpp
index e6e3ad70b28..bb1b7ff410d 100644
--- a/src/mongo/db/free_mon/free_mon_controller_test.cpp
+++ b/src/mongo/db/free_mon/free_mon_controller_test.cpp
@@ -364,8 +364,8 @@ public:
 
 
 private:
-    AtomicInt32 _registers;
-    AtomicInt32 _metrics;
+    AtomicWord<int> _registers;
+    AtomicWord<int> _metrics;
 
     executor::ThreadPoolTaskExecutor* _threadPool;
 
diff --git a/src/mongo/db/ftdc/ftdc_server.h b/src/mongo/db/ftdc/ftdc_server.h
index 265c47dfd54..1d121e0c705 100644
--- a/src/mongo/db/ftdc/ftdc_server.h
+++ b/src/mongo/db/ftdc/ftdc_server.h
@@ -105,13 +105,13 @@ private:
  * Used to provide default values from FTDCConfig to the FTDC set parameters.
  */
 struct FTDCStartupParams {
-    AtomicBool enabled;
-    AtomicInt32 periodMillis;
+    AtomicWord<bool> enabled;
+    AtomicWord<int> periodMillis;
 
-    AtomicInt32 maxDirectorySizeMB;
-    AtomicInt32 maxFileSizeMB;
-    AtomicInt32 maxSamplesPerArchiveMetricChunk;
-    AtomicInt32 maxSamplesPerInterimMetricChunk;
+    AtomicWord<int> maxDirectorySizeMB;
+    AtomicWord<int> maxFileSizeMB;
+    AtomicWord<int> maxSamplesPerArchiveMetricChunk;
+    AtomicWord<int> maxSamplesPerInterimMetricChunk;
 
     FTDCStartupParams()
         : enabled(FTDCConfig::kEnabledDefault),
diff --git a/src/mongo/db/index/duplicate_key_tracker.h b/src/mongo/db/index/duplicate_key_tracker.h
index e72b1595f86..d8047a7001d 100644
--- a/src/mongo/db/index/duplicate_key_tracker.h
+++ b/src/mongo/db/index/duplicate_key_tracker.h
@@ -75,7 +75,7 @@ public:
 private:
     const IndexCatalogEntry* _indexCatalogEntry;
 
-    AtomicInt64 _duplicateCounter{0};
+    AtomicWord<long long> _duplicateCounter{0};
 
     // This temporary record store is owned by the duplicate key tracker and dropped along with it.
     std::unique_ptr<TemporaryRecordStore> _keyConstraintsTable;
diff --git a/src/mongo/db/index/index_access_method.cpp b/src/mongo/db/index/index_access_method.cpp
index 6a9c4a52d58..081bb8a2ed2 100644
--- a/src/mongo/db/index/index_access_method.cpp
+++ b/src/mongo/db/index/index_access_method.cpp
@@ -821,7 +821,7 @@ SortedDataInterface* AbstractIndexAccessMethod::getSortedDataInterface() const {
  * places, rather than compiled in one place and linked, and so cannot provide a globally unique ID.
  */
 std::string nextFileName() {
-    static AtomicUInt32 indexAccessMethodFileCounter;
+    static AtomicWord<unsigned> indexAccessMethodFileCounter;
     return "extsort-index." + std::to_string(indexAccessMethodFileCounter.fetchAndAdd(1));
 }
 
diff --git a/src/mongo/db/index/index_build_interceptor.h b/src/mongo/db/index/index_build_interceptor.h
index 4dccc8d698c..fbfb8c298d2 100644
--- a/src/mongo/db/index/index_build_interceptor.h
+++ b/src/mongo/db/index/index_build_interceptor.h
@@ -127,7 +127,7 @@ private:
 
     int64_t _numApplied{0};
 
-    AtomicInt64 _sideWritesCounter{0};
+    AtomicWord<long long> _sideWritesCounter{0};
 
     mutable stdx::mutex _multikeyPathMutex;
     boost::optional<MultikeyPaths> _multikeyPaths;
diff --git a/src/mongo/db/index_builder.cpp b/src/mongo/db/index_builder.cpp
index a3b6fcfe019..75ada6a3b5f 100644
--- a/src/mongo/db/index_builder.cpp
+++ b/src/mongo/db/index_builder.cpp
@@ -55,7 +55,7 @@ namespace mongo {
 
 using std::endl;
 
-AtomicUInt32 IndexBuilder::_indexBuildCount;
+AtomicWord<unsigned> IndexBuilder::_indexBuildCount;
 
 namespace {
 
diff --git a/src/mongo/db/index_builder.h b/src/mongo/db/index_builder.h
index 4e11c2ad9ca..0f41d2af579 100644
--- a/src/mongo/db/index_builder.h
+++ b/src/mongo/db/index_builder.h
@@ -112,6 +112,6 @@ private:
     const ReplicatedWrites _replicatedWrites;
     const Timestamp _initIndexTs;
     std::string _name;  // name of this builder, not related to the index
-    static AtomicUInt32 _indexBuildCount;
+    static AtomicWord<unsigned> _indexBuildCount;
 };
 }
diff --git a/src/mongo/db/logical_session_cache.cpp b/src/mongo/db/logical_session_cache.cpp
index 00c82fc936a..25d52406aa2 100644
--- a/src/mongo/db/logical_session_cache.cpp
+++ b/src/mongo/db/logical_session_cache.cpp
@@ -41,7 +41,8 @@ namespace {
 const auto getLogicalSessionCache =
     ServiceContext::declareDecoration<std::unique_ptr<LogicalSessionCache>>();
 
-const auto getLogicalSessionCacheIsRegistered = ServiceContext::declareDecoration<AtomicBool>();
+const auto getLogicalSessionCacheIsRegistered =
+    ServiceContext::declareDecoration<AtomicWord<bool>>();
 }  // namespace
 
 LogicalSessionCache::~LogicalSessionCache() = default;
diff --git a/src/mongo/db/pipeline/document_source_bucket_auto.cpp b/src/mongo/db/pipeline/document_source_bucket_auto.cpp
index 7251d3cc2ef..ae724be941c 100644
--- a/src/mongo/db/pipeline/document_source_bucket_auto.cpp
+++ b/src/mongo/db/pipeline/document_source_bucket_auto.cpp
@@ -77,7 +77,7 @@ boost::intrusive_ptr<Expression> parseGroupByExpression(
  * places, rather than compiled in one place and linked, and so cannot provide a globally unique ID.
  */
 std::string nextFileName() {
-    static AtomicUInt32 documentSourceBucketAutoFileCounter;
+    static AtomicWord<unsigned> documentSourceBucketAutoFileCounter;
     return "extsort-doc-bucket." +
         std::to_string(documentSourceBucketAutoFileCounter.fetchAndAdd(1));
 }
diff --git a/src/mongo/db/pipeline/document_source_group.cpp b/src/mongo/db/pipeline/document_source_group.cpp
index 440c6c10ee9..318a67df1ff 100644
--- a/src/mongo/db/pipeline/document_source_group.cpp
+++ b/src/mongo/db/pipeline/document_source_group.cpp
@@ -59,7 +59,7 @@ namespace {
  * places, rather than compiled in one place and linked, and so cannot provide a globally unique ID.
  */
 std::string nextFileName() {
-    static AtomicUInt32 documentSourceGroupFileCounter;
+    static AtomicWord<unsigned> documentSourceGroupFileCounter;
     return "extsort-doc-group." + std::to_string(documentSourceGroupFileCounter.fetchAndAdd(1));
 }
 
diff --git a/src/mongo/db/pipeline/document_source_out_replace_coll.cpp b/src/mongo/db/pipeline/document_source_out_replace_coll.cpp
index d112672f5ea..5f4be9cbfb8 100644
--- a/src/mongo/db/pipeline/document_source_out_replace_coll.cpp
+++ b/src/mongo/db/pipeline/document_source_out_replace_coll.cpp
@@ -35,7 +35,7 @@
 
 namespace mongo {
 
-static AtomicUInt32 aggOutCounter;
+static AtomicWord<unsigned> aggOutCounter;
 
 void DocumentSourceOutReplaceColl::initializeWriteNs() {
     LocalReadConcernBlock readLocal(pExpCtx->opCtx);
diff --git a/src/mongo/db/pipeline/document_source_sort.cpp b/src/mongo/db/pipeline/document_source_sort.cpp
index 6ba8c9e8e78..475897471ed 100644
--- a/src/mongo/db/pipeline/document_source_sort.cpp
+++ b/src/mongo/db/pipeline/document_source_sort.cpp
@@ -107,7 +107,7 @@ Value deserializeSortKey(size_t sortPatternSize, BSONObj bsonSortKey) {
  * places, rather than compiled in one place and linked, and so cannot provide a globally unique ID.
  */
 std::string nextFileName() {
-    static AtomicUInt32 documentSourceSortFileCounter;
+    static AtomicWord<unsigned> documentSourceSortFileCounter;
     return "extsort-doc-source-sort." +
         std::to_string(documentSourceSortFileCounter.fetchAndAdd(1));
 }
diff --git a/src/mongo/db/query/expression_index_knobs.h b/src/mongo/db/query/expression_index_knobs.h
index 15ad7117da8..4245e97c0d4 100644
--- a/src/mongo/db/query/expression_index_knobs.h
+++ b/src/mongo/db/query/expression_index_knobs.h
@@ -41,24 +41,24 @@ namespace mongo {
 /**
  * The maximum number of cells to use for 2D geo query covering for predicate queries
  */
-extern AtomicInt32 internalGeoPredicateQuery2DMaxCoveringCells;
+extern AtomicWord<int> internalGeoPredicateQuery2DMaxCoveringCells;
 
 /**
  * The maximum number of cells to use for 2D geo query covering for predicate queries
  */
-extern AtomicInt32 internalGeoNearQuery2DMaxCoveringCells;
+extern AtomicWord<int> internalGeoNearQuery2DMaxCoveringCells;
 
 //
 // Geo query.
 //
 
 // What is the finest level we will cover a queried region or geoNear annulus?
-extern AtomicInt32 internalQueryS2GeoFinestLevel;
+extern AtomicWord<int> internalQueryS2GeoFinestLevel;
 
 // What is the coarsest level we will cover a queried region or geoNear annulus?
-extern AtomicInt32 internalQueryS2GeoCoarsestLevel;
+extern AtomicWord<int> internalQueryS2GeoCoarsestLevel;
 
 // What is the maximum cell count that we want? (advisory, not a hard threshold)
-extern AtomicInt32 internalQueryS2GeoMaxCells;
+extern AtomicWord<int> internalQueryS2GeoMaxCells;
 
 }  // namespace mongo
diff --git a/src/mongo/db/query/query_knobs.h b/src/mongo/db/query/query_knobs.h
index 3d050f804b1..976bb1a4ec3 100644
--- a/src/mongo/db/query/query_knobs.h
+++ b/src/mongo/db/query/query_knobs.h
@@ -41,34 +41,34 @@ namespace mongo {
 
 // Max number of times we call work() on plans before comparing them,
 // for small collections.
-extern AtomicInt32 internalQueryPlanEvaluationWorks;
+extern AtomicWord<int> internalQueryPlanEvaluationWorks;
 
 // For large collections, the number times we work() candidate plans is
 // taken as this fraction of the collection size.
 extern AtomicDouble internalQueryPlanEvaluationCollFraction;
 
 // Stop working plans once a plan returns this many results.
-extern AtomicInt32 internalQueryPlanEvaluationMaxResults;
+extern AtomicWord<int> internalQueryPlanEvaluationMaxResults;
 
 // Do we give a big ranking bonus to intersection plans?
-extern AtomicBool internalQueryForceIntersectionPlans;
+extern AtomicWord<bool> internalQueryForceIntersectionPlans;
 
 // Do we have ixisect on at all?
-extern AtomicBool internalQueryPlannerEnableIndexIntersection;
+extern AtomicWord<bool> internalQueryPlannerEnableIndexIntersection;
 
 // Do we use hash-based intersection for rooted $and queries?
-extern AtomicBool internalQueryPlannerEnableHashIntersection;
+extern AtomicWord<bool> internalQueryPlannerEnableHashIntersection;
 
 //
 // plan cache
 //
 
 // How many entries in the cache?
-extern AtomicInt32 internalQueryCacheSize;
+extern AtomicWord<int> internalQueryCacheSize;
 
 // How many feedback entries do we collect before possibly evicting from the cache based on bad
 // performance?
-extern AtomicInt32 internalQueryCacheFeedbacksStored;
+extern AtomicWord<int> internalQueryCacheFeedbacksStored;
 
 // How many times more works must we perform in order to justify plan cache eviction
 // and replanning?
@@ -79,66 +79,66 @@ extern AtomicDouble internalQueryCacheEvictionRatio;
 extern AtomicDouble internalQueryCacheWorksGrowthCoefficient;
 
 // Whether or not cache entries can be marked as "inactive."
-extern AtomicBool internalQueryCacheDisableInactiveEntries;
+extern AtomicWord<bool> internalQueryCacheDisableInactiveEntries;
 
 // Whether or not planCacheListPlans uses the new output format.
-extern AtomicBool internalQueryCacheListPlansNewOutput;
+extern AtomicWord<bool> internalQueryCacheListPlansNewOutput;
 
 //
 // Planning and enumeration.
 //
 
 // How many indexed solutions will QueryPlanner::plan output?
-extern AtomicInt32 internalQueryPlannerMaxIndexedSolutions;
+extern AtomicWord<int> internalQueryPlannerMaxIndexedSolutions;
 
 // How many solutions will the enumerator consider at each OR?
-extern AtomicInt32 internalQueryEnumerationMaxOrSolutions;
+extern AtomicWord<int> internalQueryEnumerationMaxOrSolutions;
 
 // How many intersections will the enumerator consider at each AND?
-extern AtomicInt32 internalQueryEnumerationMaxIntersectPerAnd;
+extern AtomicWord<int> internalQueryEnumerationMaxIntersectPerAnd;
 
 // Do we want to plan each child of the OR independently?
-extern AtomicBool internalQueryPlanOrChildrenIndependently;
+extern AtomicWord<bool> internalQueryPlanOrChildrenIndependently;
 
 // How many index scans are we willing to produce in order to obtain a sort order
 // during explodeForSort?
-extern AtomicInt32 internalQueryMaxScansToExplode;
+extern AtomicWord<int> internalQueryMaxScansToExplode;
 
 // Allow the planner to generate covered whole index scans, rather than falling back to a COLLSCAN.
-extern AtomicBool internalQueryPlannerGenerateCoveredWholeIndexScans;
+extern AtomicWord<bool> internalQueryPlannerGenerateCoveredWholeIndexScans;
 
 // Ignore unknown JSON Schema keywords.
-extern AtomicBool internalQueryIgnoreUnknownJSONSchemaKeywords;
+extern AtomicWord<bool> internalQueryIgnoreUnknownJSONSchemaKeywords;
 
 //
 // Query execution.
 //
 
-extern AtomicInt32 internalQueryExecMaxBlockingSortBytes;
+extern AtomicWord<int> internalQueryExecMaxBlockingSortBytes;
 
 // Yield after this many "should yield?" checks.
-extern AtomicInt32 internalQueryExecYieldIterations;
+extern AtomicWord<int> internalQueryExecYieldIterations;
 
 // Yield if it's been at least this many milliseconds since we last yielded.
-extern AtomicInt32 internalQueryExecYieldPeriodMS;
+extern AtomicWord<int> internalQueryExecYieldPeriodMS;
 
 // Limit the size that we write without yielding to 16MB / 64 (max expected number of indexes)
 const int64_t insertVectorMaxBytes = 256 * 1024;
 
 // The number of bytes to buffer at once during a $facet stage.
-extern AtomicInt32 internalQueryFacetBufferSizeBytes;
+extern AtomicWord<int> internalQueryFacetBufferSizeBytes;
 
-extern AtomicInt64 internalDocumentSourceSortMaxBlockingSortBytes;
+extern AtomicWord<long long> internalDocumentSourceSortMaxBlockingSortBytes;
 
-extern AtomicInt64 internalLookupStageIntermediateDocumentMaxSizeBytes;
+extern AtomicWord<long long> internalLookupStageIntermediateDocumentMaxSizeBytes;
 
-extern AtomicInt64 internalDocumentSourceGroupMaxMemoryBytes;
+extern AtomicWord<long long> internalDocumentSourceGroupMaxMemoryBytes;
 
-extern AtomicInt32 internalInsertMaxBatchSize;
+extern AtomicWord<int> internalInsertMaxBatchSize;
 
-extern AtomicInt32 internalDocumentSourceCursorBatchSizeBytes;
+extern AtomicWord<int> internalDocumentSourceCursorBatchSizeBytes;
 
-extern AtomicInt32 internalDocumentSourceLookupCacheSizeBytes;
+extern AtomicWord<int> internalDocumentSourceLookupCacheSizeBytes;
 
-extern AtomicBool internalQueryProhibitBlockingMergeOnMongoS;
+extern AtomicWord<bool> internalQueryProhibitBlockingMergeOnMongoS;
 }  // namespace mongo
diff --git a/src/mongo/db/repl/initial_syncer.cpp b/src/mongo/db/repl/initial_syncer.cpp
index 28d3266ca82..07173344dee 100644
--- a/src/mongo/db/repl/initial_syncer.cpp
+++ b/src/mongo/db/repl/initial_syncer.cpp
@@ -174,7 +174,7 @@ StatusWith<OpTimeWithHash> parseOpTimeWithHash(const QueryResponseStatus& fetchR
  */
 class InitialSyncApplyObserver : public OplogApplier::Observer {
 public:
-    explicit InitialSyncApplyObserver(AtomicUInt32* fetchCount) : _fetchCount(fetchCount) {}
+    explicit InitialSyncApplyObserver(AtomicWord<unsigned>* fetchCount) : _fetchCount(fetchCount) {}
 
     // OplogApplier::Observer functions
     void onBatchBegin(const OplogApplier::Operations&) final {}
@@ -184,7 +184,7 @@ public:
     }
 
 private:
-    AtomicUInt32* const _fetchCount;
+    AtomicWord<unsigned>* const _fetchCount;
 };
 
 }  // namespace
diff --git a/src/mongo/db/repl/initial_syncer.h b/src/mongo/db/repl/initial_syncer.h
index 929643116c5..308fdb6adaf 100644
--- a/src/mongo/db/repl/initial_syncer.h
+++ b/src/mongo/db/repl/initial_syncer.h
@@ -568,7 +568,7 @@ private:
     void _shutdownComponent_inlock(Component& component);
 
     // Counts how many documents have been refetched from the source in the current batch.
-    AtomicUInt32 _fetchCount;
+    AtomicWord<unsigned> _fetchCount;
 
     //
     // All member variables are labeled with one of the following codes indicating the
diff --git a/src/mongo/db/repl/replication_coordinator_impl.h b/src/mongo/db/repl/replication_coordinator_impl.h
index 4e29959f1df..765e4559c13 100644
--- a/src/mongo/db/repl/replication_coordinator_impl.h
+++ b/src/mongo/db/repl/replication_coordinator_impl.h
@@ -594,7 +594,7 @@ private:
         // during rollback. In order to read it, must have the RSTL. To set it when transitioning
         // into RS_ROLLBACK, must have the RSTL in mode X. Otherwise, no lock or mutex is necessary
         // to set it.
-        AtomicUInt32 _canServeNonLocalReads;
+        AtomicWord<unsigned> _canServeNonLocalReads;
     };
 
     void _resetMyLastOpTimes(WithLock lk);
@@ -1256,7 +1256,7 @@ private:
         _initialSyncer;  // (I) pointer set under mutex, copied by callers.
 
     // Hands out the next snapshot name.
-    AtomicUInt64 _snapshotNameGenerator;  // (S)
+    AtomicWord<unsigned long long> _snapshotNameGenerator;  // (S)
 
     // The OpTimes and SnapshotNames for all snapshots newer than the current commit point, kept in
     // sorted order. Any time this is changed, you must also update _uncommitedSnapshotsSize.
@@ -1264,7 +1264,7 @@ private:
 
     // A cache of the size of _uncommittedSnaphots that can be read without any locking.
     // May only be written to while holding _mutex.
-    AtomicUInt64 _uncommittedSnapshotsSize;  // (I)
+    AtomicWord<unsigned long long> _uncommittedSnapshotsSize;  // (I)
 
     // The non-null OpTime and SnapshotName of the current snapshot used for committed reads, if
     // there is one.
@@ -1317,7 +1317,7 @@ private:
     int _earliestMemberId = -1;  // (M)
 
     // Cached copy of the current config protocol version.
-    AtomicInt64 _protVersion{1};  // (S)
+    AtomicWord<long long> _protVersion{1};  // (S)
 
     // Source of random numbers used in setting election timeouts, etc.
     PseudoRandom _random;  // (M)
@@ -1330,7 +1330,7 @@ private:
     // function.
     // This variable must be written immediately after _term, and thus its value can lag.
     // Reading this value does not require the replication coordinator mutex to be locked.
-    AtomicInt64 _termShadow;  // (S)
+    AtomicWord<long long> _termShadow;  // (S)
 
     // When we decide to step down due to hearing about a higher term, we remember the term we heard
     // here so we can update our term to match as part of finishing stepdown.
diff --git a/src/mongo/db/repl/replication_coordinator_mock.h b/src/mongo/db/repl/replication_coordinator_mock.h
index a17da59ead1..72d2508ce36 100644
--- a/src/mongo/db/repl/replication_coordinator_mock.h
+++ b/src/mongo/db/repl/replication_coordinator_mock.h
@@ -289,7 +289,7 @@ public:
     virtual bool setContainsArbiter() const override;
 
 private:
-    AtomicUInt64 _snapshotNameGenerator;
+    AtomicWord<unsigned long long> _snapshotNameGenerator;
     ServiceContext* const _service;
     ReplSettings _settings;
     StorageInterface* _storage = nullptr;
diff --git a/src/mongo/db/retryable_writes_stats.h b/src/mongo/db/retryable_writes_stats.h
index 9bd027f7444..cece6da39ae 100644
--- a/src/mongo/db/retryable_writes_stats.h
+++ b/src/mongo/db/retryable_writes_stats.h
@@ -63,14 +63,14 @@ public:
 
 private:
     // The number of received commands that contained a statement that had already been executed.
-    AtomicUInt64 _retriedCommandsCount{0};
+    AtomicWord<unsigned long long> _retriedCommandsCount{0};
 
     // The number of received statements found to have been previously executed.
-    AtomicUInt64 _retriedStatementsCount{0};
+    AtomicWord<unsigned long long> _retriedStatementsCount{0};
 
     // The number of writes to the config.transactions collection. Includes writes initiated by a
     // migration.
-    AtomicUInt64 _transactionsCollectionWriteCount{0};
+    AtomicWord<unsigned long long> _transactionsCollectionWriteCount{0};
 };
 
 }  // namespace mongo
diff --git a/src/mongo/db/s/collection_range_deleter.h b/src/mongo/db/s/collection_range_deleter.h
index f6b9f161a47..88f157338a6 100644
--- a/src/mongo/db/s/collection_range_deleter.h
+++ b/src/mongo/db/s/collection_range_deleter.h
@@ -49,11 +49,11 @@ class OperationContext;
 // secondaryThrottle and rangeDeleterBatchDelayMS apply between each batch.
 // Must be positive or 0 (the default), which means to use the value of
 // internalQueryExecYieldIterations (or 1 if that's negative or zero).
-extern AtomicInt32 rangeDeleterBatchSize;
+extern AtomicWord<int> rangeDeleterBatchSize;
 
 // After completing a batch of document deletions, the time in millis to wait before commencing the
 // next batch of deletions.
-extern AtomicInt32 rangeDeleterBatchDelayMS;
+extern AtomicWord<int> rangeDeleterBatchDelayMS;
 
 class CollectionRangeDeleter {
     MONGO_DISALLOW_COPYING(CollectionRangeDeleter);
diff --git a/src/mongo/db/s/shard_server_catalog_cache_loader.cpp b/src/mongo/db/s/shard_server_catalog_cache_loader.cpp
index 038c2447c06..38a55e6f195 100644
--- a/src/mongo/db/s/shard_server_catalog_cache_loader.cpp
+++ b/src/mongo/db/s/shard_server_catalog_cache_loader.cpp
@@ -56,7 +56,7 @@ using CollectionAndChangedChunks = CatalogCacheLoader::CollectionAndChangedChunk
 
 namespace {
 
-AtomicUInt64 taskIdGenerator{0};
+AtomicWord<unsigned long long> taskIdGenerator{0};
 
 /**
  * Constructs the options for the loader thread pool.
diff --git a/src/mongo/db/s/sharding_logging.h b/src/mongo/db/s/sharding_logging.h
index 3407809d9a4..30c60d5b8bd 100644
--- a/src/mongo/db/s/sharding_logging.h
+++ b/src/mongo/db/s/sharding_logging.h
@@ -101,10 +101,10 @@ private:
     // (S) Self-synchronizing; access in any way from any context.
 
     // Whether the logAction call should attempt to create the actionlog collection
-    AtomicInt32 _actionLogCollectionCreated{0};  // (S)
+    AtomicWord<int> _actionLogCollectionCreated{0};  // (S)
 
     // Whether the logChange call should attempt to create the changelog collection
-    AtomicInt32 _changeLogCollectionCreated{0};  // (S)
+    AtomicWord<int> _changeLogCollectionCreated{0};  // (S)
 };
 
 }  // namespace mongo
diff --git a/src/mongo/db/s/sharding_state.h b/src/mongo/db/s/sharding_state.h
index fb220c9aaea..11b042a2cc9 100644
--- a/src/mongo/db/s/sharding_state.h
+++ b/src/mongo/db/s/sharding_state.h
@@ -146,7 +146,7 @@ private:
     stdx::mutex _mutex;
 
     // State of the initialization of the sharding state along with any potential errors
-    AtomicUInt32 _initializationState{static_cast<uint32_t>(InitializationState::kNew)};
+    AtomicWord<unsigned> _initializationState{static_cast<uint32_t>(InitializationState::kNew)};
 
     // Sets the shard name for this host (comes through setShardVersion)
     ShardId _shardId;
diff --git a/src/mongo/db/s/sharding_statistics.h b/src/mongo/db/s/sharding_statistics.h
index d6dee68c607..8154a67d7a8 100644
--- a/src/mongo/db/s/sharding_statistics.h
+++ b/src/mongo/db/s/sharding_statistics.h
@@ -44,40 +44,40 @@ class ServiceContext;
 struct ShardingStatistics {
     // Counts how many times threads hit stale config exception (which is what triggers metadata
     // refreshes).
-    AtomicInt64 countStaleConfigErrors{0};
+    AtomicWord<long long> countStaleConfigErrors{0};
 
     // Cumulative, always-increasing counter of how many chunks this node has started to donate
     // (whether they succeeded or not).
-    AtomicInt64 countDonorMoveChunkStarted{0};
+    AtomicWord<long long> countDonorMoveChunkStarted{0};
 
     // Cumulative, always-increasing counter of how much time the entire move chunk operation took
     // (excluding range deletion).
-    AtomicInt64 totalDonorMoveChunkTimeMillis{0};
+    AtomicWord<long long> totalDonorMoveChunkTimeMillis{0};
 
     // Cumulative, always-increasing counter of how much time the clone phase took on the donor
     // node, before it was appropriate to enter the critical section.
-    AtomicInt64 totalDonorChunkCloneTimeMillis{0};
+    AtomicWord<long long> totalDonorChunkCloneTimeMillis{0};
 
     // Cumulative, always-increasing counter of how many documents have been cloned on the
     // recipient node.
-    AtomicInt64 countDocsClonedOnRecipient{0};
+    AtomicWord<long long> countDocsClonedOnRecipient{0};
 
     // Cumulative, always-increasing counter of how many documents have been cloned on the donor
     // node.
-    AtomicInt64 countDocsClonedOnDonor{0};
+    AtomicWord<long long> countDocsClonedOnDonor{0};
 
     // Cumulative, always-increasing counter of how many documents have been deleted on the donor
     // node by the rangeDeleter.
-    AtomicInt64 countDocsDeletedOnDonor{0};
+    AtomicWord<long long> countDocsDeletedOnDonor{0};
 
     // Cumulative, always-increasing counter of how many chunks this node started to receive
     // (whether the receiving succeeded or not)
-    AtomicInt64 countRecipientMoveChunkStarted{0};
+    AtomicWord<long long> countRecipientMoveChunkStarted{0};
 
     // Cumulative, always-increasing counter of how much time the critical section's commit phase
     // took (this is the period of time when all operations on the collection are blocked, not just
     // the reads)
-    AtomicInt64 totalCriticalSectionCommitTimeMillis{0};
+    AtomicWord<long long> totalCriticalSectionCommitTimeMillis{0};
 
     // Cumulative, always-increasing counter of how much time the entire critical section took. It
     // includes the time the recipient took to fetch the latest modifications from the donor and
@@ -86,7 +86,7 @@ struct ShardingStatistics {
     // The value of totalCriticalSectionTimeMillis - totalCriticalSectionCommitTimeMillis gives the
     // duration of the catch-up phase of the critical section (where the last mods are transferred
     // from the donor to the recipient).
-    AtomicInt64 totalCriticalSectionTimeMillis{0};
+    AtomicWord<long long> totalCriticalSectionTimeMillis{0};
 
     /**
      * Obtains the per-process instance of the sharding statistics object.
diff --git a/src/mongo/db/server_options.h b/src/mongo/db/server_options.h
index 5a0d7ce18c0..de76672f6e0 100644
--- a/src/mongo/db/server_options.h
+++ b/src/mongo/db/server_options.h
@@ -61,7 +61,7 @@ struct ServerGlobalParams {
 
     bool indexBuildRetry = true;  // --noIndexBuildRetry
 
-    AtomicBool quiet{false};  // --quiet
+    AtomicWord<bool> quiet{false};  // --quiet
 
     ClusterRole clusterRole = ClusterRole::None;  // --configsvr/--shardsvr
 
@@ -121,8 +121,8 @@ struct ServerGlobalParams {
 
     AuthState authState = AuthState::kUndefined;
 
-    bool transitionToAuth = false;  // --transitionToAuth, mixed mode for rolling auth upgrade
-    AtomicInt32 clusterAuthMode;    // --clusterAuthMode, the internal cluster auth mode
+    bool transitionToAuth = false;    // --transitionToAuth, mixed mode for rolling auth upgrade
+    AtomicWord<int> clusterAuthMode;  // --clusterAuthMode, the internal cluster auth mode
 
     enum ClusterAuthModes {
         ClusterAuthMode_undefined,
diff --git a/src/mongo/db/server_parameters_test.cpp b/src/mongo/db/server_parameters_test.cpp
index 88fc191ab90..34d0d8e8b36 100644
--- a/src/mongo/db/server_parameters_test.cpp
+++ b/src/mongo/db/server_parameters_test.cpp
@@ -202,7 +202,7 @@ TEST(ServerParameters, boundIntLock) {
 }
 
 TEST(ServerParameters, Simple1) {
-    AtomicInt32 f(5);
+    AtomicWord<int> f(5);
     ExportedServerParameter<int, ServerParameterType::kStartupAndRuntime> ff(NULL, "ff", &f);
     ASSERT_EQUALS("ff", ff.name());
 
@@ -247,7 +247,7 @@ TEST(ServerParameters, Vector1) {
 }
 
 TEST(ServerParameters, Validators) {
-    AtomicInt32 myVal(0);
+    AtomicWord<int> myVal(0);
     ExportedServerParameter<int, ServerParameterType::kRuntimeOnly> myParam(
         nullptr, "myVal", &myVal);
     myParam.withValidator([](const int& newVal) {
diff --git a/src/mongo/db/server_transactions_metrics.h b/src/mongo/db/server_transactions_metrics.h
index 4f46e9ff03b..e0979dd6d67 100644
--- a/src/mongo/db/server_transactions_metrics.h
+++ b/src/mongo/db/server_transactions_metrics.h
@@ -174,34 +174,34 @@ private:
     mutable stdx::mutex _mutex;
 
     // The number of multi-document transactions currently active.
-    AtomicUInt64 _currentActive{0};
+    AtomicWord<unsigned long long> _currentActive{0};
 
     // The number of multi-document transactions currently inactive.
-    AtomicUInt64 _currentInactive{0};
+    AtomicWord<unsigned long long> _currentInactive{0};
 
     // The total number of open transactions.
-    AtomicUInt64 _currentOpen{0};
+    AtomicWord<unsigned long long> _currentOpen{0};
 
     // The total number of multi-document transactions started since the last server startup.
-    AtomicUInt64 _totalStarted{0};
+    AtomicWord<unsigned long long> _totalStarted{0};
 
     // The total number of multi-document transaction aborts.
-    AtomicUInt64 _totalAborted{0};
+    AtomicWord<unsigned long long> _totalAborted{0};
 
     // The total number of multi-document transaction commits.
-    AtomicUInt64 _totalCommitted{0};
+    AtomicWord<unsigned long long> _totalCommitted{0};
 
     // The total number of prepared transactions since the last server startup.
-    AtomicUInt64 _totalPrepared{0};
+    AtomicWord<unsigned long long> _totalPrepared{0};
 
     // The total number of prepared transaction commits.
-    AtomicUInt64 _totalPreparedThenCommitted{0};
+    AtomicWord<unsigned long long> _totalPreparedThenCommitted{0};
 
     // The total number of prepared transaction aborts.
-    AtomicUInt64 _totalPreparedThenAborted{0};
+    AtomicWord<unsigned long long> _totalPreparedThenAborted{0};
 
     // The current number of transactions in the prepared state.
-    AtomicUInt64 _currentPrepared{0};
+    AtomicWord<unsigned long long> _currentPrepared{0};
 
     // The optime of the oldest oplog entry for any active transaction.
     boost::optional<repl::OpTime> _oldestActiveOplogEntryOpTime;  // (M)
diff --git a/src/mongo/db/service_context.h b/src/mongo/db/service_context.h
index 97b4de476c1..32f2351444c 100644
--- a/src/mongo/db/service_context.h
+++ b/src/mongo/db/service_context.h
@@ -583,7 +583,7 @@ private:
     std::vector<KillOpListenerInterface*> _killOpListeners;
 
     // Counter for assigning operation ids.
-    AtomicUInt32 _nextOpId{1};
+    AtomicWord<unsigned> _nextOpId{1};
 
     bool _startupComplete = false;
     stdx::condition_variable _startupCompleteCondVar;
diff --git a/src/mongo/db/snapshot_window_options.h b/src/mongo/db/snapshot_window_options.h
index 6944e78e18f..5ede44532ee 100644
--- a/src/mongo/db/snapshot_window_options.h
+++ b/src/mongo/db/snapshot_window_options.h
@@ -49,7 +49,7 @@ struct SnapshotWindowParams {
     //
     // Note that the window size can become greater than this if an ongoing operation is holding an
     // older snapshot open.
-    AtomicInt32 maxTargetSnapshotHistoryWindowInSeconds{5};
+    AtomicWord<int> maxTargetSnapshotHistoryWindowInSeconds{5};
 
     // targetSnapshotHistoryWindowInSeconds (not a server parameter, range 0+).
     //
@@ -60,7 +60,7 @@ struct SnapshotWindowParams {
     // not always reflect it: the window can only change as more writes come in, so it can take time
     // for the actual window size to catch up with a change. This value guides actions whenever the
     // system goes to update the oldest_timestamp value.
-    AtomicInt32 targetSnapshotHistoryWindowInSeconds{
+    AtomicWord<int> targetSnapshotHistoryWindowInSeconds{
         maxTargetSnapshotHistoryWindowInSeconds.load()};
 
     // cachePressureThreshold (startup & runtime server paramter, range [0, 100]).
@@ -70,7 +70,7 @@ struct SnapshotWindowParams {
     // targetSnapshotHistoryWindowInSeconds will be ignored when the cache pressure reaches this
     // threshold. Additionally, a periodic task will decrease targetSnapshotHistoryWindowInSeconds
     // when cache pressure exceeds the threshold.
-    AtomicInt32 cachePressureThreshold{50};
+    AtomicWord<int> cachePressureThreshold{50};
 
     // snapshotWindowMultiplicativeDecrease (startup & runtime server paramter, range (0,1)).
     //
@@ -83,7 +83,7 @@ struct SnapshotWindowParams {
     // Controls by how much the target snapshot history window setting is increased when cache
     // pressure is OK, per cachePressureThreshold, and we need to service older snapshots for global
     // point-in-time reads.
-    AtomicInt32 snapshotWindowAdditiveIncreaseSeconds{2};
+    AtomicWord<int> snapshotWindowAdditiveIncreaseSeconds{2};
 
     // minMillisBetweenSnapshotWindowInc (startup & runtime server paramter, range 0+).
     // minMillisBetweenSnapshotWindowDec (startup & runtime server paramter, range 0+).
@@ -93,8 +93,8 @@ struct SnapshotWindowParams {
     // as one. This protects the system because it takes time for the target snapshot window to
     // affect the actual storage engine snapshot window. The stable timestamp must move forward for
     // the window between it and oldest timestamp to grow or shrink.
-    AtomicInt32 minMillisBetweenSnapshotWindowInc{500};
-    AtomicInt32 minMillisBetweenSnapshotWindowDec{500};
+    AtomicWord<int> minMillisBetweenSnapshotWindowInc{500};
+    AtomicWord<int> minMillisBetweenSnapshotWindowDec{500};
 
     // checkCachePressurePeriodSeconds (startup & runtime server paramter, range 1+)
     //
@@ -102,7 +102,7 @@ struct SnapshotWindowParams {
     // targetSnapshotHistoryWindowInSeconds if the pressure is above cachePressureThreshold. The
     // target window size setting must not be decreased too fast because time must be allowed for
     // the storage engine to attempt to act on the new setting.
-    AtomicInt32 checkCachePressurePeriodSeconds{5};
+    AtomicWord<int> checkCachePressurePeriodSeconds{5};
 };
 
 extern SnapshotWindowParams snapshotWindowParams;
diff --git a/src/mongo/db/sorter/sorter_test.cpp b/src/mongo/db/sorter/sorter_test.cpp
index a154912ecce..b11a8abf637 100644
--- a/src/mongo/db/sorter/sorter_test.cpp
+++ b/src/mongo/db/sorter/sorter_test.cpp
@@ -59,7 +59,7 @@ namespace mongo {
  * places, rather than compiled in one place and linked, and so cannot provide a globally unique ID.
  */
 std::string nextFileName() {
-    static AtomicUInt32 sorterTestFileCounter;
+    static AtomicWord<unsigned> sorterTestFileCounter;
     return "extsort-sorter-test." + std::to_string(sorterTestFileCounter.fetchAndAdd(1));
 }
 
diff --git a/src/mongo/db/stats/counters.cpp b/src/mongo/db/stats/counters.cpp
index 0355fa8787b..406385b28c9 100644
--- a/src/mongo/db/stats/counters.cpp
+++ b/src/mongo/db/stats/counters.cpp
@@ -68,8 +68,8 @@ void OpCounters::gotOp(int op, bool isCommand) {
     }
 }
 
-void OpCounters::_checkWrap(CacheAligned<AtomicInt64> OpCounters::*counter, int n) {
-    static constexpr auto maxCount = AtomicInt64::WordType{1} << 60;
+void OpCounters::_checkWrap(CacheAligned<AtomicWord<long long>> OpCounters::*counter, int n) {
+    static constexpr auto maxCount = 1LL << 60;
     auto oldValue = (this->*counter).fetchAndAddRelaxed(n);
     if (oldValue > maxCount) {
         _insert.store(0);
diff --git a/src/mongo/db/stats/counters.h b/src/mongo/db/stats/counters.h
index 4d6a057e427..699dbb43b12 100644
--- a/src/mongo/db/stats/counters.h
+++ b/src/mongo/db/stats/counters.h
@@ -76,35 +76,35 @@ public:
     BSONObj getObj() const;
 
     // thse are used by snmp, and other things, do not remove
-    const AtomicInt64* getInsert() const {
+    const AtomicWord<long long>* getInsert() const {
         return &_insert;
     }
-    const AtomicInt64* getQuery() const {
+    const AtomicWord<long long>* getQuery() const {
         return &_query;
     }
-    const AtomicInt64* getUpdate() const {
+    const AtomicWord<long long>* getUpdate() const {
         return &_update;
     }
-    const AtomicInt64* getDelete() const {
+    const AtomicWord<long long>* getDelete() const {
         return &_delete;
     }
-    const AtomicInt64* getGetMore() const {
+    const AtomicWord<long long>* getGetMore() const {
         return &_getmore;
     }
-    const AtomicInt64* getCommand() const {
+    const AtomicWord<long long>* getCommand() const {
         return &_command;
     }
 
 private:
     // Increment member `counter` by `n`, resetting all counters if it was > 2^60.
-    void _checkWrap(CacheAligned<AtomicInt64> OpCounters::*counter, int n);
-
-    CacheAligned<AtomicInt64> _insert;
-    CacheAligned<AtomicInt64> _query;
-    CacheAligned<AtomicInt64> _update;
-    CacheAligned<AtomicInt64> _delete;
-    CacheAligned<AtomicInt64> _getmore;
-    CacheAligned<AtomicInt64> _command;
+    void _checkWrap(CacheAligned<AtomicWord<long long>> OpCounters::*counter, int n);
+
+    CacheAligned<AtomicWord<long long>> _insert;
+    CacheAligned<AtomicWord<long long>> _query;
+    CacheAligned<AtomicWord<long long>> _update;
+    CacheAligned<AtomicWord<long long>> _delete;
+    CacheAligned<AtomicWord<long long>> _getmore;
+    CacheAligned<AtomicWord<long long>> _command;
 };
 
 extern OpCounters globalOpCounters;
@@ -124,20 +124,20 @@ public:
     void append(BSONObjBuilder& b);
 
 private:
-    CacheAligned<AtomicInt64> _physicalBytesIn{0};
-    CacheAligned<AtomicInt64> _physicalBytesOut{0};
+    CacheAligned<AtomicWord<long long>> _physicalBytesIn{0};
+    CacheAligned<AtomicWord<long long>> _physicalBytesOut{0};
 
     // These two counters are always incremented at the same time, so
     // we place them on the same cache line.
     struct Together {
-        AtomicInt64 logicalBytesIn{0};
-        AtomicInt64 requests{0};
+        AtomicWord<long long> logicalBytesIn{0};
+        AtomicWord<long long> requests{0};
     };
     CacheAligned<Together> _together{};
     static_assert(sizeof(decltype(_together)) <= stdx::hardware_constructive_interference_size,
                   "cache line spill");
 
-    CacheAligned<AtomicInt64> _logicalBytesOut{0};
+    CacheAligned<AtomicWord<long long>> _logicalBytesOut{0};
 };
 
 extern NetworkCounter networkCounter;
diff --git a/src/mongo/db/stats/timer_stats.h b/src/mongo/db/stats/timer_stats.h
index f1153f90ba5..31cbfeba9cb 100644
--- a/src/mongo/db/stats/timer_stats.h
+++ b/src/mongo/db/stats/timer_stats.h
@@ -58,8 +58,8 @@ public:
     }
 
 private:
-    AtomicInt64 _num;
-    AtomicInt64 _totalMillis;
+    AtomicWord<long long> _num;
+    AtomicWord<long long> _totalMillis;
 };
 
 /**
diff --git a/src/mongo/db/storage/biggie/biggie_record_store.h b/src/mongo/db/storage/biggie/biggie_record_store.h
index cfbaf67e8eb..ccdd5bc28b3 100644
--- a/src/mongo/db/storage/biggie/biggie_record_store.h
+++ b/src/mongo/db/storage/biggie/biggie_record_store.h
@@ -141,8 +141,8 @@ private:
 
     mutable stdx::mutex _cappedDeleterMutex;
 
-    AtomicInt64 _highest_record_id{1};
-    AtomicInt64 _numRecords{0};
+    AtomicWord<long long> _highest_record_id{1};
+    AtomicWord<long long> _numRecords{0};
     std::string generateKey(const uint8_t* key, size_t key_len) const;
 
     bool _isOplog;
diff --git a/src/mongo/db/storage/kv/kv_catalog.h b/src/mongo/db/storage/kv/kv_catalog.h
index fe670d3795a..05eff5ed241 100644
--- a/src/mongo/db/storage/kv/kv_catalog.h
+++ b/src/mongo/db/storage/kv/kv_catalog.h
@@ -143,7 +143,7 @@ private:
 
     // These two are only used for ident generation inside _newUniqueIdent.
     std::string _rand;  // effectively const after init() returns
-    AtomicUInt64 _next;
+    AtomicWord<unsigned long long> _next;
 
     struct Entry {
         Entry() {}
diff --git a/src/mongo/db/storage/mobile/mobile_record_store.h b/src/mongo/db/storage/mobile/mobile_record_store.h
index 0c31e35cd13..efab31d1c6d 100644
--- a/src/mongo/db/storage/mobile/mobile_record_store.h
+++ b/src/mongo/db/storage/mobile/mobile_record_store.h
@@ -163,7 +163,7 @@ private:
     const std::string _path;
     const std::string _ident;
 
-    AtomicInt64 _nextIdNum;
+    AtomicWord<long long> _nextIdNum;
 
     /**
      * Fetches the number of records from the database. _numRecsMutex should be locked before this
diff --git a/src/mongo/db/storage/mobile/mobile_recovery_unit.cpp b/src/mongo/db/storage/mobile/mobile_recovery_unit.cpp
index cc169d956d8..97f30ccbcb7 100644
--- a/src/mongo/db/storage/mobile/mobile_recovery_unit.cpp
+++ b/src/mongo/db/storage/mobile/mobile_recovery_unit.cpp
@@ -46,7 +46,7 @@
 
 namespace mongo {
 
-AtomicInt64 MobileRecoveryUnit::_nextID(0);
+AtomicWord<long long> MobileRecoveryUnit::_nextID(0);
 
 MobileRecoveryUnit::MobileRecoveryUnit(MobileSessionPool* sessionPool)
     : _inUnitOfWork(false), _active(false), _isReadOnly(true), _sessionPool(sessionPool) {
diff --git a/src/mongo/db/storage/mobile/mobile_recovery_unit.h b/src/mongo/db/storage/mobile/mobile_recovery_unit.h
index 982c0c70139..93620fe876c 100644
--- a/src/mongo/db/storage/mobile/mobile_recovery_unit.h
+++ b/src/mongo/db/storage/mobile/mobile_recovery_unit.h
@@ -99,7 +99,7 @@ private:
     bool _inUnitOfWork;
     bool _active;
 
-    static AtomicInt64 _nextID;
+    static AtomicWord<long long> _nextID;
     uint64_t _id;
     bool _isReadOnly;
 
diff --git a/src/mongo/db/storage/mobile/mobile_session_pool.h b/src/mongo/db/storage/mobile/mobile_session_pool.h
index 2c9b0595de9..1c57ee45f63 100644
--- a/src/mongo/db/storage/mobile/mobile_session_pool.h
+++ b/src/mongo/db/storage/mobile/mobile_session_pool.h
@@ -57,7 +57,7 @@ public:
     bool isEmpty();
 
 private:
-    AtomicBool _isEmpty;
+    AtomicWord<bool> _isEmpty;
     stdx::mutex _queueMutex;
     std::queue<std::string> _opQueryQueue;
 };
diff --git a/src/mongo/db/storage/mobile/mobile_sqlite_statement.cpp b/src/mongo/db/storage/mobile/mobile_sqlite_statement.cpp
index 0b26d25e1e7..c0ebcfa6f9f 100644
--- a/src/mongo/db/storage/mobile/mobile_sqlite_statement.cpp
+++ b/src/mongo/db/storage/mobile/mobile_sqlite_statement.cpp
@@ -46,7 +46,7 @@
 
 namespace mongo {
 
-AtomicInt64 SqliteStatement::_nextID(0);
+AtomicWord<long long> SqliteStatement::_nextID(0);
 
 SqliteStatement::SqliteStatement(const MobileSession& session, const std::string& sqlQuery) {
     // Increment the global instance count and assign this instance an id.
diff --git a/src/mongo/db/storage/mobile/mobile_sqlite_statement.h b/src/mongo/db/storage/mobile/mobile_sqlite_statement.h
index 719bc49a895..87996927902 100644
--- a/src/mongo/db/storage/mobile/mobile_sqlite_statement.h
+++ b/src/mongo/db/storage/mobile/mobile_sqlite_statement.h
@@ -131,7 +131,7 @@ public:
     uint64_t _id;
 
 private:
-    static AtomicInt64 _nextID;
+    static AtomicWord<long long> _nextID;
     sqlite3_stmt* _stmt;
     std::string _sqlQuery;
 
diff --git a/src/mongo/db/storage/storage_options.h b/src/mongo/db/storage/storage_options.h
index de4bac61aa5..d2486a66858 100644
--- a/src/mongo/db/storage/storage_options.h
+++ b/src/mongo/db/storage/storage_options.h
@@ -79,11 +79,11 @@ struct StorageGlobalParams {
 
     // --journalCommitInterval
     static const int kMaxJournalCommitIntervalMs;
-    AtomicInt32 journalCommitIntervalMs;
+    AtomicWord<int> journalCommitIntervalMs;
 
     // --notablescan
     // no table scans allowed
-    AtomicBool noTableScan;
+    AtomicWord<bool> noTableScan;
 
     // --directoryperdb
     // Stores each database’s files in its own folder in the data directory.
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.cpp
index a3c62668e37..97b2f052ed3 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.cpp
@@ -209,7 +209,7 @@ public:
 
 private:
     WiredTigerSessionCache* _sessionCache;
-    AtomicBool _shuttingDown{false};
+    AtomicWord<bool> _shuttingDown{false};
 };
 
 class WiredTigerKVEngine::WiredTigerCheckpointThread : public BackgroundJob {
@@ -373,7 +373,7 @@ private:
     // taking checkpoints. It can be triggered early to expediate immediate checkpointing.
     stdx::condition_variable _condvar;
 
-    AtomicBool _shuttingDown{false};
+    AtomicWord<bool> _shuttingDown{false};
 
     bool _hasTriggeredFirstStableCheckpoint = false;
 
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_oplog_manager.h b/src/mongo/db/storage/wiredtiger/wiredtiger_oplog_manager.h
index ef5980de8d1..3a84c939dfc 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_oplog_manager.h
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_oplog_manager.h
@@ -104,6 +104,6 @@ private:
     // journal flushing should not be delayed.
     std::int64_t _opsWaitingForVisibility = 0;  // Guarded by oplogVisibilityStateMutex.
 
-    AtomicUInt64 _oplogReadTimestamp;
+    AtomicWord<unsigned long long> _oplogReadTimestamp;
 };
 }  // namespace mongo
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.h b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.h
index 9cc17eb0b00..cc3ae0cefb9 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.h
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.h
@@ -349,8 +349,8 @@ private:
     const int64_t _cappedMaxSizeSlack;  // when to start applying backpressure
     const int64_t _cappedMaxDocs;
     RecordId _cappedFirstRecord;
-    AtomicInt64 _cappedSleep;
-    AtomicInt64 _cappedSleepMS;
+    AtomicWord<long long> _cappedSleep;
+    AtomicWord<long long> _cappedSleepMS;
     CappedCallback* _cappedCallback;
     bool _shuttingDown;
     mutable stdx::mutex _cappedCallbackMutex;  // guards _cappedCallback and _shuttingDown
@@ -359,7 +359,7 @@ private:
     int _cappedDeleteCheckCount;
     mutable stdx::timed_mutex _cappedDeleterMutex;
 
-    AtomicInt64 _nextIdNum;
+    AtomicWord<long long> _nextIdNum;
 
     WiredTigerSizeStorer* _sizeStorer;  // not owned, can be NULL
     std::shared_ptr<WiredTigerSizeStorer::SizeInfo> _sizeInfo;
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store_oplog_stones.h b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store_oplog_stones.h
index 600b92836ec..612b964240f 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store_oplog_stones.h
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store_oplog_stones.h
@@ -141,8 +141,8 @@ private:
     // deque of oplog stones.
     int64_t _minBytesPerStone;
 
-    AtomicInt64 _currentRecords;  // Number of records in the stone being filled.
-    AtomicInt64 _currentBytes;    // Number of bytes in the stone being filled.
+    AtomicWord<long long> _currentRecords;  // Number of records in the stone being filled.
+    AtomicWord<long long> _currentBytes;    // Number of bytes in the stone being filled.
 
     mutable stdx::mutex _mutex;  // Protects against concurrent access to the deque of oplog stones.
     std::deque<OplogStones::Stone> _stones;  // front = oldest, back = newest.
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp
index b2a4949f5db..e65b027686e 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp
@@ -58,7 +58,7 @@ MONGO_FAIL_POINT_DEFINE(WTAlwaysNotifyPrepareConflictWaiters);
 // SnapshotIds need to be globally unique, as they are used in a WorkingSetMember to
 // determine if documents changed, but a different recovery unit may be used across a getMore,
 // so there is a chance the snapshot ID will be reused.
-AtomicUInt64 nextSnapshotId{1};
+AtomicWord<unsigned long long> nextSnapshotId{1};
 
 logger::LogSeverity kSlowTransactionSeverity = logger::LogSeverity::Debug(1);
 
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.cpp
index 3cbdb0a075e..9c0fe8078ba 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.cpp
@@ -76,7 +76,7 @@ namespace mongo {
 // will be cached in WiredTiger. Exclusive operations should only be blocked
 // for a short time, except if a cursor is held by a long running session. This
 // is a good compromise for most workloads.
-AtomicInt32 kWiredTigerCursorCacheSize(-100);
+AtomicWord<int> kWiredTigerCursorCacheSize(-100);
 
 const std::string kWTRepairMsg =
     "Please read the documentation for starting MongoDB with --repair here: "
@@ -216,7 +216,7 @@ void WiredTigerSession::closeCursorsForQueuedDrops(WiredTigerKVEngine* engine) {
 }
 
 namespace {
-AtomicUInt64 nextTableId(1);
+AtomicWord<unsigned long long> nextTableId(1);
 }
 // static
 uint64_t WiredTigerSession::genTableId() {
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.h b/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.h
index 1d91d28f799..7a87cef036e 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.h
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.h
@@ -293,7 +293,7 @@ private:
     // Used as follows:
     //   The low 31 bits are a count of active calls to releaseSession.
     //   The high bit is a flag that is set if and only if we're shutting down.
-    AtomicUInt32 _shuttingDown;
+    AtomicWord<unsigned> _shuttingDown;
     static const uint32_t kShuttingDownMask = 1 << 31;
 
     stdx::mutex _cacheLock;
@@ -301,13 +301,13 @@ private:
     SessionCache _sessions;
 
     // Bumped when all open sessions need to be closed
-    AtomicUInt64 _epoch;  // atomic so we can check it outside of the lock
+    AtomicWord<unsigned long long> _epoch;  // atomic so we can check it outside of the lock
 
     // Bumped when all open cursors need to be closed
-    AtomicUInt64 _cursorEpoch;  // atomic so we can check it outside of the lock
+    AtomicWord<unsigned long long> _cursorEpoch;  // atomic so we can check it outside of the lock
 
     // Counter and critical section mutex for waitUntilDurable
-    AtomicUInt32 _lastSyncTime;
+    AtomicWord<unsigned> _lastSyncTime;
     stdx::mutex _lastSyncMutex;
 
     // Mutex and cond var for waiting on prepare commit or abort.
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_size_storer.h b/src/mongo/db/storage/wiredtiger/wiredtiger_size_storer.h
index f1ab4655ee4..3ded5e83c92 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_size_storer.h
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_size_storer.h
@@ -68,12 +68,12 @@ public:
         ~SizeInfo() {
             invariant(!_dirty.load());
         }
-        AtomicInt64 numRecords;
-        AtomicInt64 dataSize;
+        AtomicWord<long long> numRecords;
+        AtomicWord<long long> dataSize;
 
     private:
         friend WiredTigerSizeStorer;
-        AtomicBool _dirty;
+        AtomicWord<bool> _dirty;
     };
 
     WiredTigerSizeStorer(WT_CONNECTION* conn,
diff --git a/src/mongo/db/transaction_coordinator_driver.h b/src/mongo/db/transaction_coordinator_driver.h
index fd6bfca2e8c..df08928efcd 100644
--- a/src/mongo/db/transaction_coordinator_driver.h
+++ b/src/mongo/db/transaction_coordinator_driver.h
@@ -244,7 +244,7 @@ private:
     ThreadPool* const _pool;
 
     // TODO (SERVER-38522): Remove once AsyncWorkScheduler is used for cancellation
-    AtomicBool _cancelled{false};
+    AtomicWord<bool> _cancelled{false};
 };
 
 }  // namespace mongo
diff --git a/src/mongo/db/transaction_participant.h b/src/mongo/db/transaction_participant.h
index b8ac97b7e5f..6334090f4a0 100644
--- a/src/mongo/db/transaction_participant.h
+++ b/src/mongo/db/transaction_participant.h
@@ -56,7 +56,7 @@ namespace mongo {
 
 class OperationContext;
 
-extern AtomicInt32 transactionLifetimeLimitSeconds;
+extern AtomicWord<int> transactionLifetimeLimitSeconds;
 
 /**
  * Read timestamp to be used for a speculative transaction.  For transactions with read
diff --git a/src/mongo/db/views/view_catalog.h b/src/mongo/db/views/view_catalog.h
index 5a01bda0943..ebede346dd4 100644
--- a/src/mongo/db/views/view_catalog.h
+++ b/src/mongo/db/views/view_catalog.h
@@ -178,7 +178,7 @@ private:
     stdx::mutex _mutex;  // Protects all members, except for _valid.
     ViewMap _viewMap;
     DurableViewCatalog* _durable;
-    AtomicBool _valid;
+    AtomicWord<bool> _valid;
     ViewGraph _viewGraph;
     bool _viewGraphNeedsRefresh = true;  // Defers initializing the graph until the first insert.
 };
diff --git a/src/mongo/dbtests/plan_ranking.cpp b/src/mongo/dbtests/plan_ranking.cpp
index dfc21c9c204..61b6671976a 100644
--- a/src/mongo/dbtests/plan_ranking.cpp
+++ b/src/mongo/dbtests/plan_ranking.cpp
@@ -57,9 +57,9 @@
 namespace mongo {
 
 // How we access the external setParameter testing bool.
-extern AtomicBool internalQueryForceIntersectionPlans;
+extern AtomicWord<bool> internalQueryForceIntersectionPlans;
 
-extern AtomicBool internalQueryPlannerEnableHashIntersection;
+extern AtomicWord<bool> internalQueryPlannerEnableHashIntersection;
 
 }  // namespace mongo
 
diff --git a/src/mongo/dbtests/query_stage_multiplan.cpp b/src/mongo/dbtests/query_stage_multiplan.cpp
index 39086b0e082..db4c0de5a32 100644
--- a/src/mongo/dbtests/query_stage_multiplan.cpp
+++ b/src/mongo/dbtests/query_stage_multiplan.cpp
@@ -62,7 +62,7 @@ namespace mongo {
 const std::unique_ptr<ClockSource> clockSource = stdx::make_unique<ClockSourceMock>();
 
 // How we access the external setParameter testing bool.
-extern AtomicBool internalQueryForceIntersectionPlans;
+extern AtomicWord<bool> internalQueryForceIntersectionPlans;
 
 namespace {
 
diff --git a/src/mongo/dbtests/threadedtests.cpp b/src/mongo/dbtests/threadedtests.cpp
index 31c7bf26bc9..d8bcde1486e 100644
--- a/src/mongo/dbtests/threadedtests.cpp
+++ b/src/mongo/dbtests/threadedtests.cpp
@@ -119,7 +119,7 @@ class ThreadPoolTest {
     static const unsigned iterations = 10000;
     static const unsigned nThreads = 8;
 
-    AtomicUInt32 counter;
+    AtomicWord<unsigned> counter;
     void increment(unsigned n) {
         for (unsigned i = 0; i < n; i++) {
             counter.fetchAndAdd(1);
@@ -177,7 +177,7 @@ private:
     char pad2[128];
     unsigned locks;
     char pad3[128];
-    AtomicInt32 k;
+    AtomicWord<int> k;
 
     virtual void validate() {
         if (once++ == 0) {
@@ -199,7 +199,7 @@ private:
                 break;
         }
     }
-    AtomicBool done;
+    AtomicWord<bool> done;
     virtual void subthread(int x) {
         if (x == 1) {
             watch();
@@ -300,8 +300,8 @@ public:
         // would have very little slack.
         add<Slack<SimpleMutex, stdx::lock_guard<SimpleMutex>>>();
 
-        add<IsAtomicWordAtomic<AtomicUInt32>>();
-        add<IsAtomicWordAtomic<AtomicUInt64>>();
+        add<IsAtomicWordAtomic<AtomicWord<unsigned>>>();
+        add<IsAtomicWordAtomic<AtomicWord<unsigned long long>>>();
         add<ThreadPoolTest>();
 
         add<TicketHolderWaits>();
diff --git a/src/mongo/executor/connection_pool_tl.cpp b/src/mongo/executor/connection_pool_tl.cpp
index 00d8aeb47ad..344fcac81cc 100644
--- a/src/mongo/executor/connection_pool_tl.cpp
+++ b/src/mongo/executor/connection_pool_tl.cpp
@@ -45,7 +45,7 @@ namespace {
 const auto kMaxTimerDuration = Milliseconds::max();
 
 struct TimeoutHandler {
-    AtomicBool done;
+    AtomicWord<bool> done;
     Promise<void> promise;
 
     explicit TimeoutHandler(Promise<void> p) : promise(std::move(p)) {}
diff --git a/src/mongo/executor/connection_pool_tl.h b/src/mongo/executor/connection_pool_tl.h
index 50e63851dfe..e97dda4c44e 100644
--- a/src/mongo/executor/connection_pool_tl.h
+++ b/src/mongo/executor/connection_pool_tl.h
@@ -71,7 +71,7 @@ private:
     std::unique_ptr<NetworkConnectionHook> _onConnectHook;
 
     mutable stdx::mutex _mutex;
-    AtomicBool _inShutdown{false};
+    AtomicWord<bool> _inShutdown{false};
     stdx::unordered_set<Type*> _collars;
 };
 
diff --git a/src/mongo/executor/network_interface_tl.h b/src/mongo/executor/network_interface_tl.h
index 1dbcc7a7678..0b0c99cd03e 100644
--- a/src/mongo/executor/network_interface_tl.h
+++ b/src/mongo/executor/network_interface_tl.h
@@ -108,7 +108,7 @@ private:
         ConnHandle conn;
         std::unique_ptr<transport::ReactorTimer> timer;
 
-        AtomicBool done;
+        AtomicWord<bool> done;
         Promise<RemoteCommandResponse> promise;
     };
 
@@ -133,7 +133,7 @@ private:
     Counters _counters;
 
     std::unique_ptr<rpc::EgressMetadataHook> _metadataHook;
-    AtomicBool _inShutdown;
+    AtomicWord<bool> _inShutdown;
     stdx::thread _ioThread;
 
     stdx::mutex _inProgressMutex;
diff --git a/src/mongo/executor/remote_command_request.cpp b/src/mongo/executor/remote_command_request.cpp
index fae5dcddcfe..c0fd380745e 100644
--- a/src/mongo/executor/remote_command_request.cpp
+++ b/src/mongo/executor/remote_command_request.cpp
@@ -44,7 +44,7 @@ namespace {
 
 // Used to generate unique identifiers for requests so they can be traced throughout the
 // asynchronous networking logs
-AtomicUInt64 requestIdCounter(0);
+AtomicWord<unsigned long long> requestIdCounter(0);
 
 }  // namespace
 
diff --git a/src/mongo/executor/task_executor_pool.h b/src/mongo/executor/task_executor_pool.h
index 4d841fb17c3..b99ff1793c4 100644
--- a/src/mongo/executor/task_executor_pool.h
+++ b/src/mongo/executor/task_executor_pool.h
@@ -114,7 +114,7 @@ public:
     void appendConnectionStats(ConnectionPoolStats* stats) const;
 
 private:
-    AtomicUInt32 _counter;
+    AtomicWord<unsigned> _counter;
 
     std::vector<std::unique_ptr<TaskExecutor>> _executors;
 
diff --git a/src/mongo/executor/thread_pool_task_executor.cpp b/src/mongo/executor/thread_pool_task_executor.cpp
index 94e547b87f3..e1732e32348 100644
--- a/src/mongo/executor/thread_pool_task_executor.cpp
+++ b/src/mongo/executor/thread_pool_task_executor.cpp
@@ -93,7 +93,7 @@ public:
     // _mutex.
 
     CallbackFn callback;
-    AtomicUInt32 canceled{0U};
+    AtomicWord<unsigned> canceled{0U};
     WorkQueue::iterator iter;
     Date_t readyDate;
     bool isNetworkOperation = false;
diff --git a/src/mongo/idl/server_parameter_with_storage.h b/src/mongo/idl/server_parameter_with_storage.h
index 962312e78b4..16fa7d82789 100644
--- a/src/mongo/idl/server_parameter_with_storage.h
+++ b/src/mongo/idl/server_parameter_with_storage.h
@@ -116,7 +116,7 @@ struct LTE {
 };
 
 // Wrapped type unwrappers.
-// e.g. Given AtomicInt32, get std::int32_t and normalized store/load methods.
+// e.g. Given AtomicWord<int>, get std::int32_t and normalized store/load methods.
 template <typename U>
 struct storage_wrapper;
 
diff --git a/src/mongo/idl/server_parameter_with_storage_test.cpp b/src/mongo/idl/server_parameter_with_storage_test.cpp
index eacbeeb94bd..c813832ef72 100644
--- a/src/mongo/idl/server_parameter_with_storage_test.cpp
+++ b/src/mongo/idl/server_parameter_with_storage_test.cpp
@@ -34,8 +34,8 @@
 #include "mongo/unittest/unittest.h"
 
 namespace mongo {
-AtomicInt32 test::gStdIntPreallocated;
-AtomicInt32 test::gStdIntPreallocatedUpdateCount;
+AtomicWord<int> test::gStdIntPreallocated;
+AtomicWord<int> test::gStdIntPreallocatedUpdateCount;
 
 namespace {
 
@@ -151,8 +151,8 @@ TEST(ServerParameterWithStorage, StorageTest) {
     doStorageTestByType<double>("DoubleD", doubleVals, stringVals);
     doStorageTestByType<std::string>("String", stringVals, {});
 
-    doStorageTestByAtomic<AtomicBool>("AtomicBool", boolVals, stringVals);
-    doStorageTestByAtomic<AtomicInt32>("AtomicInt32", numberVals, stringVals);
+    doStorageTestByAtomic<AtomicWord<bool>>("AtomicWord<bool>", boolVals, stringVals);
+    doStorageTestByAtomic<AtomicWord<int>>("AtomicWord<int>", numberVals, stringVals);
     doStorageTestByAtomic<AtomicDouble>("AtomicDoubleI", numberVals, stringVals);
     doStorageTestByAtomic<AtomicDouble>("AtomicDoubleD", doubleVals, stringVals);
 }
diff --git a/src/mongo/idl/server_parameter_with_storage_test.h b/src/mongo/idl/server_parameter_with_storage_test.h
index 57f12e6aa15..f51547de377 100644
--- a/src/mongo/idl/server_parameter_with_storage_test.h
+++ b/src/mongo/idl/server_parameter_with_storage_test.h
@@ -40,10 +40,10 @@ constexpr std::int32_t kStartupIntWithExpressionsMinimum = 10;
 constexpr std::int32_t kStartupIntWithExpressionsMaximum = 1000;
 
 // Storage for set parameter defined in server_parameter_with_storage.idl
-extern AtomicInt32 gStdIntPreallocated;
+extern AtomicWord<int> gStdIntPreallocated;
 
 // Counter for how many times gStdIntPreallocated has been modified.
-extern AtomicInt32 gStdIntPreallocatedUpdateCount;
+extern AtomicWord<int> gStdIntPreallocatedUpdateCount;
 
 /**
  * Validates that the proposed new value is odd.
diff --git a/src/mongo/idl/server_parameter_with_storage_test.idl b/src/mongo/idl/server_parameter_with_storage_test.idl
index bc985613bac..f6724464fef 100644
--- a/src/mongo/idl/server_parameter_with_storage_test.idl
+++ b/src/mongo/idl/server_parameter_with_storage_test.idl
@@ -45,7 +45,7 @@ server_parameters:
   stdIntDeclared:
     set_at: [ startup, runtime ]
     description: "Create a simple int value, and declare storage"
-    cpp_vartype: AtomicInt32
+    cpp_vartype: AtomicWord<int>
     cpp_varname: gStdIntDeclared
     default: 42
     validator:
diff --git a/src/mongo/logger/component_message_log_domain.h b/src/mongo/logger/component_message_log_domain.h
index e9bfcfd4a64..5aac7b0a412 100644
--- a/src/mongo/logger/component_message_log_domain.h
+++ b/src/mongo/logger/component_message_log_domain.h
@@ -96,7 +96,7 @@ public:
 
 private:
     LogComponentSettings _settings;
-    AtomicBool _shouldRedact{false};
+    AtomicWord<bool> _shouldRedact{false};
 };
 
 }  // namespace logger
diff --git a/src/mongo/logger/log_component_settings.h b/src/mongo/logger/log_component_settings.h
index a22f2cb607d..b8afdf18011 100644
--- a/src/mongo/logger/log_component_settings.h
+++ b/src/mongo/logger/log_component_settings.h
@@ -95,12 +95,12 @@ private:
     // the same severity as kDefault.
     // This is also used to update the severities of unconfigured components when the severity
     // for kDefault is modified.
-    AtomicBool _hasMinimumLoggedSeverity[LogComponent::kNumLogComponents];
+    AtomicWord<bool> _hasMinimumLoggedSeverity[LogComponent::kNumLogComponents];
 
     // Log severities for components.
     // Store numerical values of severities to be cache-line friendly.
     // Set to kDefault minimum logged severity if _hasMinimumLoggedSeverity[i] is false.
-    AtomicInt32 _minimumLoggedSeverity[LogComponent::kNumLogComponents];
+    AtomicWord<int> _minimumLoggedSeverity[LogComponent::kNumLogComponents];
 };
 
 }  // namespace logger
diff --git a/src/mongo/logger/log_component_settings_test.cpp b/src/mongo/logger/log_component_settings_test.cpp
index fb1ae233f43..6633e09d5d5 100644
--- a/src/mongo/logger/log_component_settings_test.cpp
+++ b/src/mongo/logger/log_component_settings_test.cpp
@@ -48,7 +48,7 @@ using namespace mongo::logger;
 // cause an invariant failure, i.e. that these methods are thread-safe.
 TEST(SERVER25981Test, SetSeverityShouldLogAndClear) {
     unittest::Barrier startupBarrier(4);
-    AtomicBool running(true);
+    AtomicWord<bool> running(true);
 
     stdx::thread shouldLogThread([&]() {
         startupBarrier.countDownAndWait();
diff --git a/src/mongo/platform/atomic_word.h b/src/mongo/platform/atomic_word.h
index 5edbe2ae334..be65ae74ab6 100644
--- a/src/mongo/platform/atomic_word.h
+++ b/src/mongo/platform/atomic_word.h
@@ -183,7 +183,7 @@ public:
 }  // namespace atomic_word_detail
 
 /**
- * Instantiations of AtomicWord must be scalar types.
+ * Instantiations of AtomicWord must be trivially copyable.
  */
 template <typename T>
 class AtomicWord : public atomic_word_detail::Base<T> {
@@ -193,10 +193,4 @@ public:
     using atomic_word_detail::Base<T>::Base;
 };
 
-using AtomicUInt32 = AtomicWord<unsigned>;
-using AtomicUInt64 = AtomicWord<unsigned long long>;
-using AtomicInt32 = AtomicWord<int>;
-using AtomicInt64 = AtomicWord<long long>;
-using AtomicBool = AtomicWord<bool>;
-
 }  // namespace mongo
diff --git a/src/mongo/platform/atomic_word_test.cpp b/src/mongo/platform/atomic_word_test.cpp
index ed00ec3c70c..f097b995576 100644
--- a/src/mongo/platform/atomic_word_test.cpp
+++ b/src/mongo/platform/atomic_word_test.cpp
@@ -78,10 +78,10 @@ TEST(AtomicWordTests, BasicOperationsEnum) {
 }
 
 TEST(AtomicWordTests, BasicOperationsUnsigned32Bit) {
-    typedef AtomicUInt32::WordType WordType;
-    testAtomicWordBasicOperations<AtomicUInt32>();
+    typedef unsigned WordType;
+    testAtomicWordBasicOperations<AtomicWord<unsigned>>();
 
-    AtomicUInt32 w(0xdeadbeef);
+    AtomicWord<unsigned> w(0xdeadbeef);
     ASSERT_EQUALS(WordType(0xdeadbeef), w.compareAndSwap(0, 1));
     ASSERT_EQUALS(WordType(0xdeadbeef), w.compareAndSwap(0xdeadbeef, 0xcafe1234));
     ASSERT_EQUALS(WordType(0xcafe1234), w.fetchAndAdd(0xf000));
@@ -90,10 +90,10 @@ TEST(AtomicWordTests, BasicOperationsUnsigned32Bit) {
 }
 
 TEST(AtomicWordTests, BasicOperationsUnsigned64Bit) {
-    typedef AtomicUInt64::WordType WordType;
-    testAtomicWordBasicOperations<AtomicUInt64>();
+    typedef unsigned long long WordType;
+    testAtomicWordBasicOperations<AtomicWord<unsigned long long>>();
 
-    AtomicUInt64 w(0xdeadbeefcafe1234ULL);
+    AtomicWord<unsigned long long> w(0xdeadbeefcafe1234ULL);
     ASSERT_EQUALS(WordType(0xdeadbeefcafe1234ULL), w.compareAndSwap(0, 1));
     ASSERT_EQUALS(WordType(0xdeadbeefcafe1234ULL),
                   w.compareAndSwap(0xdeadbeefcafe1234ULL, 0xfedcba9876543210ULL));
@@ -103,10 +103,10 @@ TEST(AtomicWordTests, BasicOperationsUnsigned64Bit) {
 }
 
 TEST(AtomicWordTests, BasicOperationsSigned32Bit) {
-    typedef AtomicInt32::WordType WordType;
-    testAtomicWordBasicOperations<AtomicInt32>();
+    typedef int WordType;
+    testAtomicWordBasicOperations<AtomicWord<int>>();
 
-    AtomicInt32 w(0xdeadbeef);
+    AtomicWord<int> w(0xdeadbeef);
     ASSERT_EQUALS(WordType(0xdeadbeef), w.compareAndSwap(0, 1));
     ASSERT_EQUALS(WordType(0xdeadbeef), w.compareAndSwap(0xdeadbeef, 0xcafe1234));
     ASSERT_EQUALS(WordType(0xcafe1234), w.fetchAndAdd(0xf000));
@@ -115,10 +115,10 @@ TEST(AtomicWordTests, BasicOperationsSigned32Bit) {
 }
 
 TEST(AtomicWordTests, BasicOperationsSigned64Bit) {
-    typedef AtomicInt64::WordType WordType;
-    testAtomicWordBasicOperations<AtomicInt64>();
+    typedef long long WordType;
+    testAtomicWordBasicOperations<AtomicWord<long long>>();
 
-    AtomicInt64 w(0xdeadbeefcafe1234ULL);
+    AtomicWord<long long> w(0xdeadbeefcafe1234ULL);
     ASSERT_EQUALS(WordType(0xdeadbeefcafe1234LL), w.compareAndSwap(0, 1));
     ASSERT_EQUALS(WordType(0xdeadbeefcafe1234LL),
                   w.compareAndSwap(0xdeadbeefcafe1234LL, 0xfedcba9876543210LL));
diff --git a/src/mongo/rpc/op_msg.cpp b/src/mongo/rpc/op_msg.cpp
index ebb07db09b7..305b7ba2066 100644
--- a/src/mongo/rpc/op_msg.cpp
+++ b/src/mongo/rpc/op_msg.cpp
@@ -221,7 +221,7 @@ BSONObjBuilder OpMsgBuilder::resumeBody() {
     return BSONObjBuilder(BSONObjBuilder::ResumeBuildingTag(), _buf, _bodyStart);
 }
 
-AtomicBool OpMsgBuilder::disableDupeFieldCheck_forTest{false};
+AtomicWord<bool> OpMsgBuilder::disableDupeFieldCheck_forTest{false};
 
 Message OpMsgBuilder::finish() {
     if (kDebugBuild && !disableDupeFieldCheck_forTest.load()) {
diff --git a/src/mongo/rpc/op_msg.h b/src/mongo/rpc/op_msg.h
index fdafcb002c4..88799e56896 100644
--- a/src/mongo/rpc/op_msg.h
+++ b/src/mongo/rpc/op_msg.h
@@ -221,7 +221,7 @@ public:
      * the server handles them. Is false by default, although the check only happens in debug
      * builds.
      */
-    static AtomicBool disableDupeFieldCheck_forTest;
+    static AtomicWord<bool> disableDupeFieldCheck_forTest;
 
     /**
      * Similar to finish, any calls on this object after are illegal.
diff --git a/src/mongo/s/balancer_configuration.h b/src/mongo/s/balancer_configuration.h
index cce8d35ea9a..4c069654b3f 100644
--- a/src/mongo/s/balancer_configuration.h
+++ b/src/mongo/s/balancer_configuration.h
@@ -284,8 +284,8 @@ private:
 
     // Max chunk size after which a chunk would be considered jumbo and won't be moved. This value
     // is read on the critical path after each write operation, that's why it is cached.
-    AtomicUInt64 _maxChunkSizeBytes;
-    AtomicBool _shouldAutoSplit;
+    AtomicWord<unsigned long long> _maxChunkSizeBytes;
+    AtomicWord<bool> _shouldAutoSplit;
 };
 
 }  // namespace mongo
diff --git a/src/mongo/s/catalog_cache.h b/src/mongo/s/catalog_cache.h
index c7f53a2ab27..7dd03763160 100644
--- a/src/mongo/s/catalog_cache.h
+++ b/src/mongo/s/catalog_cache.h
@@ -347,28 +347,28 @@ private:
     struct Stats {
         // Counts how many times threads hit stale config exception (which is what triggers metadata
         // refreshes)
-        AtomicInt64 countStaleConfigErrors{0};
+        AtomicWord<long long> countStaleConfigErrors{0};
 
         // Cumulative, always-increasing counter of how much time threads waiting for refresh
         // combined
-        AtomicInt64 totalRefreshWaitTimeMicros{0};
+        AtomicWord<long long> totalRefreshWaitTimeMicros{0};
 
         // Tracks how many incremental refreshes are waiting to complete currently
-        AtomicInt64 numActiveIncrementalRefreshes{0};
+        AtomicWord<long long> numActiveIncrementalRefreshes{0};
 
         // Cumulative, always-increasing counter of how many incremental refreshes have been kicked
         // off
-        AtomicInt64 countIncrementalRefreshesStarted{0};
+        AtomicWord<long long> countIncrementalRefreshesStarted{0};
 
         // Tracks how many full refreshes are waiting to complete currently
-        AtomicInt64 numActiveFullRefreshes{0};
+        AtomicWord<long long> numActiveFullRefreshes{0};
 
         // Cumulative, always-increasing counter of how many full refreshes have been kicked off
-        AtomicInt64 countFullRefreshesStarted{0};
+        AtomicWord<long long> countFullRefreshesStarted{0};
 
         // Cumulative, always-increasing counter of how many full or incremental refreshes failed
         // for whatever reason
-        AtomicInt64 countFailedRefreshes{0};
+        AtomicWord<long long> countFailedRefreshes{0};
 
         /**
          * Reports the accumulated statistics for serverStatus.
diff --git a/src/mongo/s/chunk_manager.cpp b/src/mongo/s/chunk_manager.cpp
index ca5e9a61cad..f569c25d75e 100644
--- a/src/mongo/s/chunk_manager.cpp
+++ b/src/mongo/s/chunk_manager.cpp
@@ -49,7 +49,7 @@ namespace mongo {
 namespace {
 
 // Used to generate sequence numbers to assign to each newly created RoutingTableHistory
-AtomicUInt32 nextCMSequenceNumber(0);
+AtomicWord<unsigned> nextCMSequenceNumber(0);
 
 void checkAllElementsAreOfType(BSONType type, const BSONObj& o) {
     for (auto&& element : o) {
diff --git a/src/mongo/s/chunk_writes_tracker.h b/src/mongo/s/chunk_writes_tracker.h
index 4dfb379b4a8..17e421e144f 100644
--- a/src/mongo/s/chunk_writes_tracker.h
+++ b/src/mongo/s/chunk_writes_tracker.h
@@ -86,7 +86,7 @@ private:
      * The number of bytes that have been written to this chunk. May be
      * modified concurrently by several threads.
      */
-    AtomicUInt64 _bytesWritten{0};
+    AtomicWord<unsigned long long> _bytesWritten{0};
 
     /**
      * Protects _splitState when starting a split.
diff --git a/src/mongo/s/commands/cluster_map_reduce_cmd.cpp b/src/mongo/s/commands/cluster_map_reduce_cmd.cpp
index c2343f1bdae..79eaa10c92f 100644
--- a/src/mongo/s/commands/cluster_map_reduce_cmd.cpp
+++ b/src/mongo/s/commands/cluster_map_reduce_cmd.cpp
@@ -62,7 +62,7 @@
 namespace mongo {
 namespace {
 
-AtomicUInt32 JOB_NUMBER;
+AtomicWord<unsigned> JOB_NUMBER;
 
 const Milliseconds kNoDistLockTimeout(-1);
 
diff --git a/src/mongo/s/grid.h b/src/mongo/s/grid.h
index f102da3c8de..7dbc69ab025 100644
--- a/src/mongo/s/grid.h
+++ b/src/mongo/s/grid.h
@@ -191,7 +191,7 @@ private:
 
     CustomConnectionPoolStatsFn _customConnectionPoolStatsFn;
 
-    AtomicBool _shardingInitialized{false};
+    AtomicWord<bool> _shardingInitialized{false};
 
     // Protects _configOpTime.
     mutable stdx::mutex _mutex;
diff --git a/src/mongo/s/query/cluster_query_knobs.h b/src/mongo/s/query/cluster_query_knobs.h
index 9277958b72a..8ba6093c75f 100644
--- a/src/mongo/s/query/cluster_query_knobs.h
+++ b/src/mongo/s/query/cluster_query_knobs.h
@@ -39,15 +39,15 @@ namespace mongo {
 // will be selected randomly amongst the shards participating in the query. Pipelines capable of
 // merging on mongoS are unaffected by this setting, unless internalQueryProhibitMergingOnMongoS is
 // true.
-extern AtomicBool internalQueryAlwaysMergeOnPrimaryShard;
+extern AtomicWord<bool> internalQueryAlwaysMergeOnPrimaryShard;
 
 // If set to true on mongos, all aggregations which could otherwise merge on the mongos will be
 // obliged to merge on a shard instead. Pipelines which are redirected to the shards will obey the
 // value of internalQueryAlwaysMergeOnPrimaryShard. False by default, meaning that pipelines capable
 // of merging on mongoS will always do so.
-extern AtomicBool internalQueryProhibitMergingOnMongoS;
+extern AtomicWord<bool> internalQueryProhibitMergingOnMongoS;
 
 // If set to true on mongos then the cluster query planner will not produce plans with the exchange.
 // False by default, so the queries run with exchanges.
-extern AtomicBool internalQueryDisableExchange;
+extern AtomicWord<bool> internalQueryDisableExchange;
 }  // namespace mongo
diff --git a/src/mongo/scripting/engine.cpp b/src/mongo/scripting/engine.cpp
index f66b42579d5..203c6857e3e 100644
--- a/src/mongo/scripting/engine.cpp
+++ b/src/mongo/scripting/engine.cpp
@@ -54,7 +54,7 @@ using std::shared_ptr;
 using std::string;
 using std::unique_ptr;
 
-AtomicInt64 Scope::_lastVersion(1);
+AtomicWord<long long> Scope::_lastVersion(1);
 
 
 namespace {
diff --git a/src/mongo/scripting/engine.h b/src/mongo/scripting/engine.h
index 2aa7dd2f127..cfe130ec650 100644
--- a/src/mongo/scripting/engine.h
+++ b/src/mongo/scripting/engine.h
@@ -219,7 +219,7 @@ protected:
     std::string _localDBName;
     int64_t _loadedVersion;
     std::set<std::string> _storedNames;
-    static AtomicInt64 _lastVersion;
+    static AtomicWord<long long> _lastVersion;
     FunctionCacheMap _cachedFunctions;
     int _numTimesUsed;
     bool _lastRetIsNativeCode;  // v8 only: set to true if eval'd script returns a native func
diff --git a/src/mongo/shell/bench.h b/src/mongo/shell/bench.h
index 322494539d3..6f30a3b76fc 100644
--- a/src/mongo/shell/bench.h
+++ b/src/mongo/shell/bench.h
@@ -453,8 +453,8 @@ private:
     unsigned _numUnstartedWorkers;
     unsigned _numActiveWorkers;
 
-    AtomicUInt32 _isShuttingDown;
-    AtomicUInt32 _isCollectingStats;
+    AtomicWord<unsigned> _isShuttingDown;
+    AtomicWord<unsigned> _isCollectingStats;
 };
 
 /**
diff --git a/src/mongo/shell/dbshell.cpp b/src/mongo/shell/dbshell.cpp
index 4f49ca027cc..9306a719b6f 100644
--- a/src/mongo/shell/dbshell.cpp
+++ b/src/mongo/shell/dbshell.cpp
@@ -89,7 +89,7 @@ using namespace mongo;
 string historyFile;
 bool gotInterrupted = false;
 bool inMultiLine = false;
-static AtomicBool atPrompt(false);  // can eval before getting to prompt
+static AtomicWord<bool> atPrompt(false);  // can eval before getting to prompt
 
 namespace {
 const std::string kDefaultMongoHost = "127.0.0.1"s;
diff --git a/src/mongo/stdx/condition_variable.h b/src/mongo/stdx/condition_variable.h
index 5a72a6443bf..7f1ed7ef5fa 100644
--- a/src/mongo/stdx/condition_variable.h
+++ b/src/mongo/stdx/condition_variable.h
@@ -170,7 +170,7 @@ private:
         return true;
     }
 
-    AtomicUInt64 _notifyableCount;
+    AtomicWord<unsigned long long> _notifyableCount;
 
     stdx::mutex _mutex;
     std::list<Notifyable**> _notifyables;
diff --git a/src/mongo/transport/message_compressor_base.h b/src/mongo/transport/message_compressor_base.h
index b7db9b6707b..e83531b517d 100644
--- a/src/mongo/transport/message_compressor_base.h
+++ b/src/mongo/transport/message_compressor_base.h
@@ -146,10 +146,10 @@ private:
     const MessageCompressorId _id;
     const std::string _name;
 
-    AtomicInt64 _compressBytesIn;
-    AtomicInt64 _compressBytesOut;
+    AtomicWord<long long> _compressBytesIn;
+    AtomicWord<long long> _compressBytesOut;
 
-    AtomicInt64 _decompressBytesIn;
-    AtomicInt64 _decompressBytesOut;
+    AtomicWord<long long> _decompressBytesIn;
+    AtomicWord<long long> _decompressBytesOut;
 };
 }  // namespace mongo
diff --git a/src/mongo/transport/service_executor_adaptive_test.cpp b/src/mongo/transport/service_executor_adaptive_test.cpp
index a95065e873b..66d00b1dfd9 100644
--- a/src/mongo/transport/service_executor_adaptive_test.cpp
+++ b/src/mongo/transport/service_executor_adaptive_test.cpp
@@ -311,7 +311,7 @@ TEST_F(ServiceExecutorAdaptiveFixture, TestStarvation) {
 TEST_F(ServiceExecutorAdaptiveFixture, TestRecursion) {
     auto exec = makeAndStartExecutor<RecursionOptions>();
 
-    AtomicInt32 remainingTasks{config->recursionLimit() - 1};
+    AtomicWord<int> remainingTasks{config->recursionLimit() - 1};
     stdx::mutex mutex;
     stdx::condition_variable cv;
     stdx::function<void()> task;
diff --git a/src/mongo/transport/service_executor_reserved.h b/src/mongo/transport/service_executor_reserved.h
index da5e07fc3e1..cdcdaa010e5 100644
--- a/src/mongo/transport/service_executor_reserved.h
+++ b/src/mongo/transport/service_executor_reserved.h
@@ -73,7 +73,7 @@ private:
     static thread_local int _localRecursionDepth;
     static thread_local int64_t _localThreadIdleCounter;
 
-    AtomicBool _stillRunning{false};
+    AtomicWord<bool> _stillRunning{false};
 
     mutable stdx::mutex _mutex;
     stdx::condition_variable _threadWakeup;
@@ -81,7 +81,7 @@ private:
 
     std::deque<Task> _readyTasks;
 
-    AtomicUInt32 _numRunningWorkerThreads{0};
+    AtomicWord<unsigned> _numRunningWorkerThreads{0};
     size_t _numReadyThreads{0};
     size_t _numStartingThreads{0};
 
diff --git a/src/mongo/transport/service_executor_synchronous.h b/src/mongo/transport/service_executor_synchronous.h
index 319994efabe..d57783a1e17 100644
--- a/src/mongo/transport/service_executor_synchronous.h
+++ b/src/mongo/transport/service_executor_synchronous.h
@@ -65,7 +65,7 @@ private:
     static thread_local int _localRecursionDepth;
     static thread_local int64_t _localThreadIdleCounter;
 
-    AtomicBool _stillRunning{false};
+    AtomicWord<bool> _stillRunning{false};
 
     mutable stdx::mutex _shutdownMutex;
     stdx::condition_variable _shutdownCondition;
diff --git a/src/mongo/transport/session.cpp b/src/mongo/transport/session.cpp
index c99262a0071..1e832454aaa 100644
--- a/src/mongo/transport/session.cpp
+++ b/src/mongo/transport/session.cpp
@@ -41,7 +41,7 @@ namespace transport {
 
 namespace {
 
-AtomicUInt64 sessionIdCounter(0);
+AtomicWord<unsigned long long> sessionIdCounter(0);
 
 }  // namespace
 
diff --git a/src/mongo/transport/transport_layer_asio.cpp b/src/mongo/transport/transport_layer_asio.cpp
index 59659ba3378..64697fb10a3 100644
--- a/src/mongo/transport/transport_layer_asio.cpp
+++ b/src/mongo/transport/transport_layer_asio.cpp
@@ -524,7 +524,7 @@ Future<SessionHandle> TransportLayerASIO::asyncConnect(HostAndPort peer,
               resolver(context),
               peer(std::move(peer)) {}
 
-        AtomicBool done{false};
+        AtomicWord<bool> done{false};
         Promise<SessionHandle> promise;
 
         stdx::mutex mutex;
diff --git a/src/mongo/util/assert_util.cpp b/src/mongo/util/assert_util.cpp
index e08cc30a5b1..5fcd57250c0 100644
--- a/src/mongo/util/assert_util.cpp
+++ b/src/mongo/util/assert_util.cpp
@@ -74,7 +74,7 @@ void AssertionCount::condrollover(int newvalue) {
         rollover();
 }
 
-AtomicBool DBException::traceExceptions(false);
+AtomicWord<bool> DBException::traceExceptions(false);
 
 void DBException::traceIfNeeded(const DBException& e) {
     if (traceExceptions.load()) {
diff --git a/src/mongo/util/assert_util.h b/src/mongo/util/assert_util.h
index c31fdce0d57..fd8b81ea272 100644
--- a/src/mongo/util/assert_util.h
+++ b/src/mongo/util/assert_util.h
@@ -52,11 +52,11 @@ public:
     void rollover();
     void condrollover(int newValue);
 
-    AtomicInt32 regular;
-    AtomicInt32 warning;
-    AtomicInt32 msg;
-    AtomicInt32 user;
-    AtomicInt32 rollovers;
+    AtomicWord<int> regular;
+    AtomicWord<int> warning;
+    AtomicWord<int> msg;
+    AtomicWord<int> user;
+    AtomicWord<int> rollovers;
 };
 
 extern AssertionCount assertionCount;
@@ -123,7 +123,7 @@ public:
         return _status.extraInfo<ErrorDetail>();
     }
 
-    static AtomicBool traceExceptions;
+    static AtomicWord<bool> traceExceptions;
 
 protected:
     DBException(const Status& status) : _status(status) {
diff --git a/src/mongo/util/background_thread_clock_source.h b/src/mongo/util/background_thread_clock_source.h
index 6bfb5fa8f92..2f8eac34ecf 100644
--- a/src/mongo/util/background_thread_clock_source.h
+++ b/src/mongo/util/background_thread_clock_source.h
@@ -75,8 +75,8 @@ private:
     int64_t _updateCurrent_inlock();
 
     const std::unique_ptr<ClockSource> _clockSource;
-    AtomicInt64 _current{0};           // 0 if _timer is paused due to idleness.
-    AtomicBool _timerWillPause{true};  // If true when _timer wakes up, it will pause.
+    AtomicWord<long long> _current{0};       // 0 if _timer is paused due to idleness.
+    AtomicWord<bool> _timerWillPause{true};  // If true when _timer wakes up, it will pause.
 
     const Milliseconds _granularity;
 
diff --git a/src/mongo/util/concurrency/thread_name.cpp b/src/mongo/util/concurrency/thread_name.cpp
index b632052330c..c6d6f68617d 100644
--- a/src/mongo/util/concurrency/thread_name.cpp
+++ b/src/mongo/util/concurrency/thread_name.cpp
@@ -90,7 +90,7 @@ void setWindowsThreadName(DWORD dwThreadID, const char* threadName) {
 }
 #endif
 
-AtomicInt64 nextUnnamedThreadId{1};
+AtomicWord<long long> nextUnnamedThreadId{1};
 
 // It is unsafe to access threadName before its dynamic initialization has completed. Use
 // the execution of mongo initializers (which only happens once we have entered main, and
diff --git a/src/mongo/util/concurrency/thread_pool.cpp b/src/mongo/util/concurrency/thread_pool.cpp
index 83114e8bda2..158396e6a93 100644
--- a/src/mongo/util/concurrency/thread_pool.cpp
+++ b/src/mongo/util/concurrency/thread_pool.cpp
@@ -47,7 +47,7 @@ namespace mongo {
 namespace {
 
 // Counter used to assign unique names to otherwise-unnamed thread pools.
-AtomicInt32 nextUnnamedThreadPoolId{1};
+AtomicWord<int> nextUnnamedThreadPoolId{1};
 
 /**
  * Sets defaults and checks bounds limits on "options", and returns it.
diff --git a/src/mongo/util/concurrency/ticketholder.h b/src/mongo/util/concurrency/ticketholder.h
index 0865e36a430..4b1ffcb5ce0 100644
--- a/src/mongo/util/concurrency/ticketholder.h
+++ b/src/mongo/util/concurrency/ticketholder.h
@@ -87,12 +87,12 @@ private:
     mutable sem_t _sem;
 
     // You can read _outof without a lock, but have to hold _resizeMutex to change.
-    AtomicInt32 _outof;
+    AtomicWord<int> _outof;
     stdx::mutex _resizeMutex;
 #else
     bool _tryAcquire();
 
-    AtomicInt32 _outof;
+    AtomicWord<int> _outof;
     int _num;
     stdx::mutex _mutex;
     stdx::condition_variable _newTicket;
diff --git a/src/mongo/util/debug_util.h b/src/mongo/util/debug_util.h
index 84068f0e1aa..e2b487d84d4 100644
--- a/src/mongo/util/debug_util.h
+++ b/src/mongo/util/debug_util.h
@@ -55,7 +55,7 @@ public:
     }
 
 private:
-    AtomicInt64 _count{0};
+    AtomicWord<long long> _count{0};
 };
 
 struct Occasionally : SampleEveryNth<16> {};
diff --git a/src/mongo/util/exit.cpp b/src/mongo/util/exit.cpp
index 3269cec3b39..2c2f9409e83 100644
--- a/src/mongo/util/exit.cpp
+++ b/src/mongo/util/exit.cpp
@@ -52,7 +52,7 @@ stdx::mutex shutdownMutex;
 stdx::condition_variable shutdownTasksComplete;
 boost::optional<ExitCode> shutdownExitCode;
 bool shutdownTasksInProgress = false;
-AtomicUInt32 shutdownFlag;
+AtomicWord<unsigned> shutdownFlag;
 std::stack<stdx::function<void()>> shutdownTasks;
 stdx::thread::id shutdownTasksThreadId;
 
diff --git a/src/mongo/util/fail_point.cpp b/src/mongo/util/fail_point.cpp
index d8512c6985d..324a4056eb5 100644
--- a/src/mongo/util/fail_point.cpp
+++ b/src/mongo/util/fail_point.cpp
@@ -159,7 +159,7 @@ FailPoint::RetCode FailPoint::slowShouldFailOpenBlock(
         case alwaysOn:
             return slowOn;
         case random: {
-            const AtomicInt32::WordType maxActivationValue = _timesOrPeriod.load();
+            const int maxActivationValue = _timesOrPeriod.load();
             if (FailPointPRNG::current()->nextPositiveInt32() < maxActivationValue)
                 return slowOn;
 
diff --git a/src/mongo/util/fail_point.h b/src/mongo/util/fail_point.h
index cbb7ab3bfe7..380fcbd5753 100644
--- a/src/mongo/util/fail_point.h
+++ b/src/mongo/util/fail_point.h
@@ -73,7 +73,7 @@ class FailPoint {
     MONGO_DISALLOW_COPYING(FailPoint);
 
 public:
-    typedef AtomicUInt32::WordType ValType;
+    typedef unsigned ValType;
     enum Mode { off, alwaysOn, random, nTimes, skip };
     enum RetCode { fastOff = 0, slowOff, slowOn, userIgnored };
 
@@ -171,11 +171,11 @@ private:
     // Bit layout:
     // 31: tells whether this fail point is active.
     // 0~30: unsigned ref counter for active dynamic instances.
-    AtomicUInt32 _fpInfo{0};
+    AtomicWord<unsigned> _fpInfo{0};
 
     // Invariant: These should be read only if ACTIVE_BIT of _fpInfo is set.
     Mode _mode{off};
-    AtomicInt32 _timesOrPeriod{0};
+    AtomicWord<int> _timesOrPeriod{0};
     BSONObj _data;
 
     // protects _mode, _timesOrPeriod, _data
diff --git a/src/mongo/util/intrusive_counter.h b/src/mongo/util/intrusive_counter.h
index 3b4cd6280eb..b78f83809df 100644
--- a/src/mongo/util/intrusive_counter.h
+++ b/src/mongo/util/intrusive_counter.h
@@ -66,7 +66,7 @@ protected:
     virtual ~RefCountable() {}
 
 private:
-    mutable AtomicUInt32 _count;  // default initialized to 0
+    mutable AtomicWord<unsigned> _count;  // default initialized to 0
 };
 
 /// This is an immutable reference-counted string
diff --git a/src/mongo/util/invalidating_lru_cache_test.cpp b/src/mongo/util/invalidating_lru_cache_test.cpp
index d1a485c6043..4ef42056693 100644
--- a/src/mongo/util/invalidating_lru_cache_test.cpp
+++ b/src/mongo/util/invalidating_lru_cache_test.cpp
@@ -59,7 +59,7 @@ public:
     }
 
 private:
-    AtomicBool _isValid{true};
+    AtomicWord<bool> _isValid{true};
     boost::optional<stdx::function<bool()>> _isValidHook;
 };
 
diff --git a/src/mongo/util/net/ssl_manager.h b/src/mongo/util/net/ssl_manager.h
index fa2abc656a5..b8360df1a96 100644
--- a/src/mongo/util/net/ssl_manager.h
+++ b/src/mongo/util/net/ssl_manager.h
@@ -143,11 +143,11 @@ const ASN1OID mongodbRolesOID("1.3.6.1.4.1.34601.2.1.1",
  * Counts of negogtiated version used by TLS connections.
  */
 struct TLSVersionCounts {
-    AtomicInt64 tlsUnknown;
-    AtomicInt64 tls10;
-    AtomicInt64 tls11;
-    AtomicInt64 tls12;
-    AtomicInt64 tls13;
+    AtomicWord<long long> tlsUnknown;
+    AtomicWord<long long> tls10;
+    AtomicWord<long long> tls11;
+    AtomicWord<long long> tls12;
+    AtomicWord<long long> tls13;
 
     static TLSVersionCounts& get(ServiceContext* serviceContext);
 };
diff --git a/src/mongo/util/net/ssl_options.cpp b/src/mongo/util/net/ssl_options.cpp
index b86c4d0e130..fde6a4fa57f 100644
--- a/src/mongo/util/net/ssl_options.cpp
+++ b/src/mongo/util/net/ssl_options.cpp
@@ -201,7 +201,7 @@ StatusWith<SSLParams::SSLModes> SSLParams::tlsModeParse(StringData strMode) {
 }
 
 
-std::string SSLParams::sslModeFormat(AtomicInt32::WordType mode) {
+std::string SSLParams::sslModeFormat(int mode) {
     switch (mode) {
         case SSLParams::SSLMode_disabled:
             return "disabled";
@@ -212,12 +212,12 @@ std::string SSLParams::sslModeFormat(AtomicInt32::WordType mode) {
         case SSLParams::SSLMode_requireSSL:
             return "requireSSL";
         default:
-            // Default case because sslMode is an AtomicInt32 and not bound by enum rules.
+            // Default case because sslMode is an AtomicWord<int> and not bound by enum rules.
             return "unknown";
     }
 }
 
-std::string SSLParams::tlsModeFormat(AtomicInt32::WordType mode) {
+std::string SSLParams::tlsModeFormat(int mode) {
     switch (mode) {
         case SSLParams::SSLMode_disabled:
             return "disabled";
@@ -228,7 +228,7 @@ std::string SSLParams::tlsModeFormat(AtomicInt32::WordType mode) {
         case SSLParams::SSLMode_requireSSL:
             return "requireTLS";
         default:
-            // Default case because sslMode is an AtomicInt32 and not bound by enum rules.
+            // Default case because sslMode is an AtomicWord<int> and not bound by enum rules.
             return "unknown";
     }
 }
diff --git a/src/mongo/util/net/ssl_options.h b/src/mongo/util/net/ssl_options.h
index acfcceea486..9bbb026ab08 100644
--- a/src/mongo/util/net/ssl_options.h
+++ b/src/mongo/util/net/ssl_options.h
@@ -51,7 +51,7 @@ class Environment;
 
 struct SSLParams {
     enum class Protocols { TLS1_0, TLS1_1, TLS1_2, TLS1_3 };
-    AtomicInt32 sslMode;            // --tlsMode - the TLS operation mode, see enum SSLModes
+    AtomicWord<int> sslMode;        // --tlsMode - the TLS operation mode, see enum SSLModes
     std::string sslPEMTempDHParam;  // --setParameter OpenSSLDiffieHellmanParameters=file : PEM file
                                     // with DH parameters.
     std::string sslPEMKeyFile;      // --tlsCertificateKeyFile
@@ -92,7 +92,7 @@ struct SSLParams {
         sslMode.store(SSLMode_disabled);
     }
 
-    enum SSLModes : AtomicInt32::WordType {
+    enum SSLModes : int {
         /**
         * Make unencrypted outgoing connections and do not accept incoming SSL-connections.
         */
@@ -116,8 +116,8 @@ struct SSLParams {
 
     static StatusWith<SSLModes> sslModeParse(StringData strMode);
     static StatusWith<SSLModes> tlsModeParse(StringData strMode);
-    static std::string sslModeFormat(AtomicInt32::WordType mode);
-    static std::string tlsModeFormat(AtomicInt32::WordType mode);
+    static std::string sslModeFormat(int mode);
+    static std::string tlsModeFormat(int mode);
 };
 
 extern SSLParams sslGlobalParams;
diff --git a/src/mongo/util/net/ssl_parameters.cpp b/src/mongo/util/net/ssl_parameters.cpp
index 2fe9e66cb43..aafbb453268 100644
--- a/src/mongo/util/net/ssl_parameters.cpp
+++ b/src/mongo/util/net/ssl_parameters.cpp
@@ -54,7 +54,8 @@ std::string clusterAuthModeFormat() {
         case ServerGlobalParams::ClusterAuthMode_x509:
             return "x509";
         default:
-            // Default case because clusterAuthMode is an AtomicInt32 and not bound by enum rules.
+            // Default case because clusterAuthMode is an AtomicWord<int> and not bound by enum
+            // rules.
             return "undefined";
     }
 }
diff --git a/src/mongo/util/shared_buffer.h b/src/mongo/util/shared_buffer.h
index add4a5c2325..5a583163d26 100644
--- a/src/mongo/util/shared_buffer.h
+++ b/src/mongo/util/shared_buffer.h
@@ -101,7 +101,7 @@ public:
 private:
     class Holder {
     public:
-        explicit Holder(AtomicUInt32::WordType initial, size_t capacity)
+        explicit Holder(unsigned initial, size_t capacity)
             : _refCount(initial), _capacity(capacity) {
             invariant(capacity == _capacity);
         }
@@ -132,7 +132,7 @@ private:
             return _refCount.load() > 1;
         }
 
-        AtomicUInt32 _refCount;
+        AtomicWord<unsigned> _refCount;
         uint32_t _capacity;
     };