diff --git a/powerstats/AocStateResidencyDataProvider.cpp b/powerstats/AocStateResidencyDataProvider.cpp
index c64496d..38cd85f 100644
--- a/powerstats/AocStateResidencyDataProvider.cpp
+++ b/powerstats/AocStateResidencyDataProvider.cpp
@@ -24,12 +24,12 @@
 namespace power {
 namespace stats {
 
-AocStateResidencyDataProvider::AocStateResidencyDataProvider(std::vector<std::pair<std::string,
-        std::string>> ids, std::vector<std::pair<std::string, std::string>> states) {
-    // AoC stats are reported in ticks of 244.140625ns. The transform
-    // function converts ticks to milliseconds.
-    // 1000000 / 244.140625 = 4096.
-    static const uint64_t AOC_CLK = 4096;
+AocStateResidencyDataProvider::AocStateResidencyDataProvider(
+        std::vector<std::pair<std::string, std::string>> ids,
+        std::vector<std::pair<std::string, std::string>> states,
+        const uint64_t aocClock) {
+    // AoC stats are reported in ticks.
+    static const uint64_t AOC_CLK = aocClock;
     std::function<uint64_t(uint64_t)> aocTickToMs = [](uint64_t a) { return a / AOC_CLK; };
     GenericStateResidencyDataProvider::StateResidencyConfig config = {
             .entryCountSupported = true,
diff --git a/powerstats/AocTimedStateResidencyDataProvider.cpp b/powerstats/AocTimedStateResidencyDataProvider.cpp
index ca427f6..ead2a42 100644
--- a/powerstats/AocTimedStateResidencyDataProvider.cpp
+++ b/powerstats/AocTimedStateResidencyDataProvider.cpp
@@ -28,8 +28,9 @@
 AocTimedStateResidencyDataProvider::AocTimedStateResidencyDataProvider(
     std::vector<std::pair<std::string, std::string>> ids,
     std::vector<std::pair<std::string, std::string>> states,
-    const uint64_t timeoutMillis)
-    : AocStateResidencyDataProvider(ids, states) {
+    const uint64_t timeoutMillis,
+    const uint64_t aocClock)
+    : AocStateResidencyDataProvider(ids, states, aocClock) {
   static const uint64_t DEFAULT_MAX_TIME_PER_STATE_MILLIS = 120;
 
   mTimeoutMillis =
diff --git a/powerstats/include/AocStateResidencyDataProvider.h b/powerstats/include/AocStateResidencyDataProvider.h
index f02b911..708ea4c 100644
--- a/powerstats/include/AocStateResidencyDataProvider.h
+++ b/powerstats/include/AocStateResidencyDataProvider.h
@@ -27,7 +27,8 @@
 class AocStateResidencyDataProvider : public PowerStats::IStateResidencyDataProvider {
   public:
     AocStateResidencyDataProvider(std::vector<std::pair<std::string, std::string>> ids,
-                                  std::vector<std::pair<std::string, std::string>> states);
+                                  std::vector<std::pair<std::string, std::string>> states,
+                                  const uint64_t aocClock);
     ~AocStateResidencyDataProvider() = default;
     bool getStateResidencies(
         std::unordered_map<std::string, std::vector<StateResidency>> *residencies) override;
diff --git a/powerstats/include/AocTimedStateResidencyDataProvider.h b/powerstats/include/AocTimedStateResidencyDataProvider.h
index 98724b2..8611ae6 100644
--- a/powerstats/include/AocTimedStateResidencyDataProvider.h
+++ b/powerstats/include/AocTimedStateResidencyDataProvider.h
@@ -39,7 +39,8 @@
   AocTimedStateResidencyDataProvider(
       std::vector<std::pair<std::string, std::string>> ids,
       std::vector<std::pair<std::string, std::string>> states,
-      const uint64_t timeoutMillis);
+      const uint64_t timeoutMillis,
+      const uint64_t aocClock);
   ~AocTimedStateResidencyDataProvider() = default;
 
   bool getStateResidencies(
