diff --git a/src/hotspot/os/aix/os_aix.cpp b/src/hotspot/os/aix/os_aix.cpp
index f88729cdc66..d7c1911a914 100644
--- a/src/hotspot/os/aix/os_aix.cpp
+++ b/src/hotspot/os/aix/os_aix.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2026, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2012, 2025 SAP SE. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -258,10 +258,18 @@ bool os::free_memory(physical_memory_size_type& value) {
   return Aix::available_memory(value);
 }
 
+bool os::Machine::free_memory(physical_memory_size_type& value) {
+  return Aix::available_memory(value);
+}
+
 bool os::available_memory(physical_memory_size_type& value) {
   return Aix::available_memory(value);
 }
 
+bool os::Machine::available_memory(physical_memory_size_type& value) {
+  return Aix::available_memory(value);
+}
+
 bool os::Aix::available_memory(physical_memory_size_type& value) {
   os::Aix::meminfo_t mi;
   if (os::Aix::get_meminfo(&mi)) {
@@ -273,6 +281,10 @@ bool os::Aix::available_memory(physical_memory_size_type& value) {
 }
 
 bool os::total_swap_space(physical_memory_size_type& value) {
+  return Machine::total_swap_space(value);
+}
+
+bool os::Machine::total_swap_space(physical_memory_size_type& value) {
   perfstat_memory_total_t memory_info;
   if (libperfstat::perfstat_memory_total(nullptr, &memory_info, sizeof(perfstat_memory_total_t), 1) == -1) {
     return false;
@@ -282,6 +294,10 @@ bool os::total_swap_space(physical_memory_size_type& value) {
 }
 
 bool os::free_swap_space(physical_memory_size_type& value) {
+  return Machine::free_swap_space(value);
+}
+
+bool os::Machine::free_swap_space(physical_memory_size_type& value) {
   perfstat_memory_total_t memory_info;
   if (libperfstat::perfstat_memory_total(nullptr, &memory_info, sizeof(perfstat_memory_total_t), 1) == -1) {
     return false;
@@ -294,6 +310,10 @@ physical_memory_size_type os::physical_memory() {
   return Aix::physical_memory();
 }
 
+physical_memory_size_type os::Machine::physical_memory() {
+  return Aix::physical_memory();
+}
+
 size_t os::rss() { return (size_t)0; }
 
 // Cpu architecture string
@@ -2264,6 +2284,10 @@ int os::active_processor_count() {
     return ActiveProcessorCount;
   }
 
+  return Machine::active_processor_count();
+}
+
+int os::Machine::active_processor_count() {
   int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN);
   assert(online_cpus > 0 && online_cpus <= processor_count(), "sanity check");
   return online_cpus;
diff --git a/src/hotspot/os/bsd/os_bsd.cpp b/src/hotspot/os/bsd/os_bsd.cpp
index 61de48bb7fa..667810bd6ca 100644
--- a/src/hotspot/os/bsd/os_bsd.cpp
+++ b/src/hotspot/os/bsd/os_bsd.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -137,10 +137,18 @@ bool os::available_memory(physical_memory_size_type& value) {
   return Bsd::available_memory(value);
 }
 
+bool os::Machine::available_memory(physical_memory_size_type& value) {
+  return Bsd::available_memory(value);
+}
+
 bool os::free_memory(physical_memory_size_type& value) {
   return Bsd::available_memory(value);
 }
 
+bool os::Machine::free_memory(physical_memory_size_type& value) {
+  return Bsd::available_memory(value);
+}
+
 // Available here means free. Note that this number is of no much use. As an estimate
 // for future memory pressure it is far too conservative, since MacOS will use a lot
 // of unused memory for caches, and return it willingly in case of needs.
@@ -181,6 +189,10 @@ void os::Bsd::print_uptime_info(outputStream* st) {
 }
 
 bool os::total_swap_space(physical_memory_size_type& value) {
+  return Machine::total_swap_space(value);
+}
+
+bool os::Machine::total_swap_space(physical_memory_size_type& value) {
 #if defined(__APPLE__)
   struct xsw_usage vmusage;
   size_t size = sizeof(vmusage);
@@ -195,6 +207,10 @@ bool os::total_swap_space(physical_memory_size_type& value) {
 }
 
 bool os::free_swap_space(physical_memory_size_type& value) {
+  return Machine::free_swap_space(value);
+}
+
+bool os::Machine::free_swap_space(physical_memory_size_type& value) {
 #if defined(__APPLE__)
   struct xsw_usage vmusage;
   size_t size = sizeof(vmusage);
@@ -212,6 +228,10 @@ physical_memory_size_type os::physical_memory() {
   return Bsd::physical_memory();
 }
 
+physical_memory_size_type os::Machine::physical_memory() {
+  return Bsd::physical_memory();
+}
+
 size_t os::rss() {
   size_t rss = 0;
 #ifdef __APPLE__
@@ -2189,6 +2209,10 @@ int os::active_processor_count() {
     return ActiveProcessorCount;
   }
 
+  return Machine::active_processor_count();
+}
+
+int os::Machine::active_processor_count() {
   return _processor_count;
 }
 
diff --git a/src/hotspot/os/linux/cgroupSubsystem_linux.cpp b/src/hotspot/os/linux/cgroupSubsystem_linux.cpp
index f9c6f794ebd..e49d070890e 100644
--- a/src/hotspot/os/linux/cgroupSubsystem_linux.cpp
+++ b/src/hotspot/os/linux/cgroupSubsystem_linux.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -631,22 +631,20 @@ void CgroupSubsystemFactory::cleanup(CgroupInfo* cg_infos) {
  * return:
  *    true if there were no errors. false otherwise.
  */
-bool CgroupSubsystem::active_processor_count(int& value) {
-  int cpu_count;
-  int result = -1;
-
+bool CgroupSubsystem::active_processor_count(double& value) {
   // We use a cache with a timeout to avoid performing expensive
   // computations in the event this function is called frequently.
   // [See 8227006].
-  CachingCgroupController<CgroupCpuController>* contrl = cpu_controller();
-  CachedMetric* cpu_limit = contrl->metrics_cache();
+  CachingCgroupController<CgroupCpuController, double>* contrl = cpu_controller();
+  CachedMetric<double>* cpu_limit = contrl->metrics_cache();
   if (!cpu_limit->should_check_metric()) {
-    value = (int)cpu_limit->value();
-    log_trace(os, container)("CgroupSubsystem::active_processor_count (cached): %d", value);
+    value = cpu_limit->value();
+    log_trace(os, container)("CgroupSubsystem::active_processor_count (cached): %.2f", value);
     return true;
   }
 
-  cpu_count = os::Linux::active_processor_count();
+  int cpu_count = os::Linux::active_processor_count();
+  double result = -1;
   if (!CgroupUtil::processor_count(contrl->controller(), cpu_count, result)) {
     return false;
   }
@@ -671,8 +669,8 @@ bool CgroupSubsystem::active_processor_count(int& value) {
  */
 bool CgroupSubsystem::memory_limit_in_bytes(physical_memory_size_type upper_bound,
                                             physical_memory_size_type& value) {
-  CachingCgroupController<CgroupMemoryController>* contrl = memory_controller();
-  CachedMetric* memory_limit = contrl->metrics_cache();
+  CachingCgroupController<CgroupMemoryController, physical_memory_size_type>* contrl = memory_controller();
+  CachedMetric<physical_memory_size_type>* memory_limit = contrl->metrics_cache();
   if (!memory_limit->should_check_metric()) {
     value = memory_limit->value();
     return true;
diff --git a/src/hotspot/os/linux/cgroupSubsystem_linux.hpp b/src/hotspot/os/linux/cgroupSubsystem_linux.hpp
index 522b64f8816..8aafbf49c63 100644
--- a/src/hotspot/os/linux/cgroupSubsystem_linux.hpp
+++ b/src/hotspot/os/linux/cgroupSubsystem_linux.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -181,9 +181,10 @@ class CgroupController: public CHeapObj<mtInternal> {
     static bool limit_from_str(char* limit_str, physical_memory_size_type& value);
 };
 
+template <typename MetricType>
 class CachedMetric : public CHeapObj<mtInternal>{
   private:
-    volatile physical_memory_size_type _metric;
+    volatile MetricType _metric;
     volatile jlong _next_check_counter;
   public:
     CachedMetric() {
@@ -193,8 +194,8 @@ class CachedMetric : public CHeapObj<mtInternal>{
     bool should_check_metric() {
       return os::elapsed_counter() > _next_check_counter;
     }
-    physical_memory_size_type value() { return _metric; }
-    void set_value(physical_memory_size_type value, jlong timeout) {
+    MetricType value() { return _metric; }
+    void set_value(MetricType value, jlong timeout) {
       _metric = value;
       // Metric is unlikely to change, but we want to remain
       // responsive to configuration changes. A very short grace time
@@ -205,19 +206,19 @@ class CachedMetric : public CHeapObj<mtInternal>{
     }
 };
 
-template <class T>
+template <class T, typename MetricType>
 class CachingCgroupController : public CHeapObj<mtInternal> {
   private:
     T* _controller;
-    CachedMetric* _metrics_cache;
+    CachedMetric<MetricType>* _metrics_cache;
 
   public:
     CachingCgroupController(T* cont) {
       _controller = cont;
-      _metrics_cache = new CachedMetric();
+      _metrics_cache = new CachedMetric<MetricType>();
     }
 
-    CachedMetric* metrics_cache() { return _metrics_cache; }
+    CachedMetric<MetricType>* metrics_cache() { return _metrics_cache; }
     T* controller() { return _controller; }
 };
 
@@ -277,7 +278,7 @@ class CgroupMemoryController: public CHeapObj<mtInternal> {
 class CgroupSubsystem: public CHeapObj<mtInternal> {
   public:
     bool memory_limit_in_bytes(physical_memory_size_type upper_bound, physical_memory_size_type& value);
-    bool active_processor_count(int& value);
+    bool active_processor_count(double& value);
 
     virtual bool pids_max(uint64_t& value) = 0;
     virtual bool pids_current(uint64_t& value) = 0;
@@ -286,8 +287,8 @@ class CgroupSubsystem: public CHeapObj<mtInternal> {
     virtual char * cpu_cpuset_cpus() = 0;
     virtual char * cpu_cpuset_memory_nodes() = 0;
     virtual const char * container_type() = 0;
-    virtual CachingCgroupController<CgroupMemoryController>* memory_controller() = 0;
-    virtual CachingCgroupController<CgroupCpuController>* cpu_controller() = 0;
+    virtual CachingCgroupController<CgroupMemoryController, physical_memory_size_type>* memory_controller() = 0;
+    virtual CachingCgroupController<CgroupCpuController, double>* cpu_controller() = 0;
     virtual CgroupCpuacctController* cpuacct_controller() = 0;
 
     bool cpu_quota(int& value);
diff --git a/src/hotspot/os/linux/cgroupUtil_linux.cpp b/src/hotspot/os/linux/cgroupUtil_linux.cpp
index 7aa07d53148..570b335940b 100644
--- a/src/hotspot/os/linux/cgroupUtil_linux.cpp
+++ b/src/hotspot/os/linux/cgroupUtil_linux.cpp
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2024, 2025, Red Hat, Inc.
+ * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,9 +26,8 @@
 #include "cgroupUtil_linux.hpp"
 #include "os_linux.hpp"
 
-bool CgroupUtil::processor_count(CgroupCpuController* cpu_ctrl, int upper_bound, int& value) {
+bool CgroupUtil::processor_count(CgroupCpuController* cpu_ctrl, int upper_bound, double& value) {
   assert(upper_bound > 0, "upper bound of cpus must be positive");
-  int limit_count = upper_bound;
   int quota = -1;
   int period = -1;
   if (!cpu_ctrl->cpu_quota(quota)) {
@@ -37,20 +37,15 @@ bool CgroupUtil::processor_count(CgroupCpuController* cpu_ctrl, int upper_bound,
     return false;
   }
   int quota_count = 0;
-  int result = upper_bound;
+  double result = upper_bound;
 
-  if (quota > -1 && period > 0) {
-    quota_count = ceilf((float)quota / (float)period);
-    log_trace(os, container)("CPU Quota count based on quota/period: %d", quota_count);
+  if (quota > 0 && period > 0) { // Use quotas
+    double cpu_quota = static_cast<double>(quota) / period;
+    log_trace(os, container)("CPU Quota based on quota/period: %.2f", cpu_quota);
+    result = MIN2(result, cpu_quota);
   }
 
-  // Use quotas
-  if (quota_count != 0) {
-    limit_count = quota_count;
-  }
-
-  result = MIN2(upper_bound, limit_count);
-  log_trace(os, container)("OSContainer::active_processor_count: %d", result);
+  log_trace(os, container)("OSContainer::active_processor_count: %.2f", result);
   value = result;
   return true;
 }
@@ -73,11 +68,11 @@ physical_memory_size_type CgroupUtil::get_updated_mem_limit(CgroupMemoryControll
 
 // Get an updated cpu limit. The return value is strictly less than or equal to the
 // passed in 'lowest' value.
-int CgroupUtil::get_updated_cpu_limit(CgroupCpuController* cpu,
+double CgroupUtil::get_updated_cpu_limit(CgroupCpuController* cpu,
                                      int lowest,
                                      int upper_bound) {
   assert(lowest > 0 && lowest <= upper_bound, "invariant");
-  int cpu_limit_val = -1;
+  double cpu_limit_val = -1;
   if (CgroupUtil::processor_count(cpu, upper_bound, cpu_limit_val) && cpu_limit_val != upper_bound) {
     assert(cpu_limit_val <= upper_bound, "invariant");
     if (lowest > cpu_limit_val) {
@@ -172,7 +167,7 @@ void CgroupUtil::adjust_controller(CgroupCpuController* cpu) {
   assert(cg_path[0] == '/', "cgroup path must start with '/'");
   int host_cpus = os::Linux::active_processor_count();
   int lowest_limit = host_cpus;
-  int cpus = get_updated_cpu_limit(cpu, lowest_limit, host_cpus);
+  double cpus = get_updated_cpu_limit(cpu, lowest_limit, host_cpus);
   int orig_limit = lowest_limit != host_cpus ? lowest_limit : host_cpus;
   char* limit_cg_path = nullptr;
   while ((last_slash = strrchr(cg_path, '/')) != cg_path) {
diff --git a/src/hotspot/os/linux/cgroupUtil_linux.hpp b/src/hotspot/os/linux/cgroupUtil_linux.hpp
index d72bbd1cf1e..1fd2a7d872b 100644
--- a/src/hotspot/os/linux/cgroupUtil_linux.hpp
+++ b/src/hotspot/os/linux/cgroupUtil_linux.hpp
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2024, Red Hat, Inc.
+ * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -31,7 +32,7 @@
 class CgroupUtil: AllStatic {
 
   public:
-    static bool processor_count(CgroupCpuController* cpu, int upper_bound, int& value);
+    static bool processor_count(CgroupCpuController* cpu, int upper_bound, double& value);
     // Given a memory controller, adjust its path to a point in the hierarchy
     // that represents the closest memory limit.
     static void adjust_controller(CgroupMemoryController* m);
@@ -42,9 +43,7 @@ class CgroupUtil: AllStatic {
     static physical_memory_size_type get_updated_mem_limit(CgroupMemoryController* m,
                                                            physical_memory_size_type lowest,
                                                            physical_memory_size_type upper_bound);
-    static int get_updated_cpu_limit(CgroupCpuController* c,
-                                     int lowest,
-                                     int upper_bound);
+    static double get_updated_cpu_limit(CgroupCpuController* c, int lowest, int upper_bound);
 };
 
 #endif // CGROUP_UTIL_LINUX_HPP
diff --git a/src/hotspot/os/linux/cgroupV1Subsystem_linux.cpp b/src/hotspot/os/linux/cgroupV1Subsystem_linux.cpp
index 2df604083d2..c8f5a290c99 100644
--- a/src/hotspot/os/linux/cgroupV1Subsystem_linux.cpp
+++ b/src/hotspot/os/linux/cgroupV1Subsystem_linux.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -328,8 +328,8 @@ CgroupV1Subsystem::CgroupV1Subsystem(CgroupV1Controller* cpuset,
     _pids(pids) {
   CgroupUtil::adjust_controller(memory);
   CgroupUtil::adjust_controller(cpu);
-  _memory = new CachingCgroupController<CgroupMemoryController>(memory);
-  _cpu = new CachingCgroupController<CgroupCpuController>(cpu);
+  _memory = new CachingCgroupController<CgroupMemoryController, physical_memory_size_type>(memory);
+  _cpu = new CachingCgroupController<CgroupCpuController, double>(cpu);
 }
 
 bool CgroupV1Subsystem::is_containerized() {
diff --git a/src/hotspot/os/linux/cgroupV1Subsystem_linux.hpp b/src/hotspot/os/linux/cgroupV1Subsystem_linux.hpp
index f556bc57f26..af8d0efd378 100644
--- a/src/hotspot/os/linux/cgroupV1Subsystem_linux.hpp
+++ b/src/hotspot/os/linux/cgroupV1Subsystem_linux.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -214,15 +214,15 @@ class CgroupV1Subsystem: public CgroupSubsystem {
     const char * container_type() override {
       return "cgroupv1";
     }
-    CachingCgroupController<CgroupMemoryController>* memory_controller() override { return _memory; }
-    CachingCgroupController<CgroupCpuController>* cpu_controller() override { return _cpu; }
+    CachingCgroupController<CgroupMemoryController, physical_memory_size_type>* memory_controller() override { return _memory; }
+    CachingCgroupController<CgroupCpuController, double>* cpu_controller() override { return _cpu; }
     CgroupCpuacctController* cpuacct_controller() override { return _cpuacct; }
 
   private:
     /* controllers */
-    CachingCgroupController<CgroupMemoryController>* _memory = nullptr;
+    CachingCgroupController<CgroupMemoryController, physical_memory_size_type>* _memory = nullptr;
     CgroupV1Controller* _cpuset = nullptr;
-    CachingCgroupController<CgroupCpuController>* _cpu = nullptr;
+    CachingCgroupController<CgroupCpuController, double>* _cpu = nullptr;
     CgroupV1CpuacctController* _cpuacct = nullptr;
     CgroupV1Controller* _pids = nullptr;
 
diff --git a/src/hotspot/os/linux/cgroupV2Subsystem_linux.cpp b/src/hotspot/os/linux/cgroupV2Subsystem_linux.cpp
index c61d30e9236..30e1affc646 100644
--- a/src/hotspot/os/linux/cgroupV2Subsystem_linux.cpp
+++ b/src/hotspot/os/linux/cgroupV2Subsystem_linux.cpp
@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2020, 2025, Red Hat Inc.
- * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2025, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -156,8 +156,8 @@ CgroupV2Subsystem::CgroupV2Subsystem(CgroupV2MemoryController * memory,
                                      _unified(unified) {
   CgroupUtil::adjust_controller(memory);
   CgroupUtil::adjust_controller(cpu);
-  _memory = new CachingCgroupController<CgroupMemoryController>(memory);
-  _cpu = new CachingCgroupController<CgroupCpuController>(cpu);
+  _memory = new CachingCgroupController<CgroupMemoryController, physical_memory_size_type>(memory);
+  _cpu = new CachingCgroupController<CgroupCpuController, double>(cpu);
   _cpuacct = cpuacct;
 }
 
diff --git a/src/hotspot/os/linux/cgroupV2Subsystem_linux.hpp b/src/hotspot/os/linux/cgroupV2Subsystem_linux.hpp
index 39a4fabe9f6..998145c0ff9 100644
--- a/src/hotspot/os/linux/cgroupV2Subsystem_linux.hpp
+++ b/src/hotspot/os/linux/cgroupV2Subsystem_linux.hpp
@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2020, 2024, Red Hat Inc.
- * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2025, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -152,8 +152,8 @@ class CgroupV2Subsystem: public CgroupSubsystem {
     /* One unified controller */
     CgroupV2Controller _unified;
     /* Caching wrappers for cpu/memory metrics */
-    CachingCgroupController<CgroupMemoryController>* _memory = nullptr;
-    CachingCgroupController<CgroupCpuController>* _cpu = nullptr;
+    CachingCgroupController<CgroupMemoryController, physical_memory_size_type>* _memory = nullptr;
+    CachingCgroupController<CgroupCpuController, double>* _cpu = nullptr;
 
     CgroupCpuacctController* _cpuacct = nullptr;
 
@@ -175,8 +175,8 @@ class CgroupV2Subsystem: public CgroupSubsystem {
     const char * container_type() override {
       return "cgroupv2";
     }
-    CachingCgroupController<CgroupMemoryController>* memory_controller() override { return _memory; }
-    CachingCgroupController<CgroupCpuController>* cpu_controller() override { return _cpu; }
+    CachingCgroupController<CgroupMemoryController, physical_memory_size_type>* memory_controller() override { return _memory; }
+    CachingCgroupController<CgroupCpuController, double>* cpu_controller() override { return _cpu; }
     CgroupCpuacctController* cpuacct_controller() override { return _cpuacct; };
 };
 
diff --git a/src/hotspot/os/linux/osContainer_linux.cpp b/src/hotspot/os/linux/osContainer_linux.cpp
index 15a6403d07f..fe1dbc17239 100644
--- a/src/hotspot/os/linux/osContainer_linux.cpp
+++ b/src/hotspot/os/linux/osContainer_linux.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -86,8 +86,8 @@ void OSContainer::init() {
     //  2.) On a physical Linux system with a limit enforced by other means (like systemd slice)
     physical_memory_size_type mem_limit_val = value_unlimited;
     (void)memory_limit_in_bytes(mem_limit_val);  // discard error and use default
-    int host_cpus = os::Linux::active_processor_count();
-    int cpus = host_cpus;
+    double host_cpus = os::Linux::active_processor_count();
+    double cpus = host_cpus;
     (void)active_processor_count(cpus);  // discard error and use default
     any_mem_cpu_limit_present = mem_limit_val != value_unlimited || host_cpus != cpus;
     if (any_mem_cpu_limit_present) {
@@ -127,8 +127,7 @@ bool OSContainer::available_memory_in_bytes(physical_memory_size_type& value) {
   return false;
 }
 
-bool OSContainer::available_swap_in_bytes(physical_memory_size_type host_free_swap,
-                                          physical_memory_size_type& value) {
+bool OSContainer::available_swap_in_bytes(physical_memory_size_type& value) {
   physical_memory_size_type mem_limit = 0;
   physical_memory_size_type mem_swap_limit = 0;
   if (memory_limit_in_bytes(mem_limit) &&
@@ -179,8 +178,7 @@ bool OSContainer::available_swap_in_bytes(physical_memory_size_type host_free_sw
     assert(num < 25, "buffer too small");
     mem_limit_buf[num] = '\0';
     log_trace(os,container)("OSContainer::available_swap_in_bytes: container_swap_limit=%s"
-                            " container_mem_limit=%s, host_free_swap: " PHYS_MEM_TYPE_FORMAT,
-                            mem_swap_buf, mem_limit_buf, host_free_swap);
+                            " container_mem_limit=%s", mem_swap_buf, mem_limit_buf);
   }
   return false;
 }
@@ -252,7 +250,7 @@ char * OSContainer::cpu_cpuset_memory_nodes() {
   return cgroup_subsystem->cpu_cpuset_memory_nodes();
 }
 
-bool OSContainer::active_processor_count(int& value) {
+bool OSContainer::active_processor_count(double& value) {
   assert(cgroup_subsystem != nullptr, "cgroup subsystem not available");
   return cgroup_subsystem->active_processor_count(value);
 }
@@ -291,11 +289,13 @@ template<typename T> struct metric_fmt;
 template<> struct metric_fmt<unsigned long long int> { static constexpr const char* fmt = "%llu"; };
 template<> struct metric_fmt<unsigned long int> { static constexpr const char* fmt = "%lu"; };
 template<> struct metric_fmt<int> { static constexpr const char* fmt = "%d"; };
+template<> struct metric_fmt<double> { static constexpr const char* fmt = "%.2f"; };
 template<> struct metric_fmt<const char*> { static constexpr const char* fmt = "%s"; };
 
 template void OSContainer::print_container_metric<unsigned long long int>(outputStream*, const char*, unsigned long long int, const char*);
 template void OSContainer::print_container_metric<unsigned long int>(outputStream*, const char*, unsigned long int, const char*);
 template void OSContainer::print_container_metric<int>(outputStream*, const char*, int, const char*);
+template void OSContainer::print_container_metric<double>(outputStream*, const char*, double, const char*);
 template void OSContainer::print_container_metric<const char*>(outputStream*, const char*, const char*, const char*);
 
 template <typename T>
diff --git a/src/hotspot/os/linux/osContainer_linux.hpp b/src/hotspot/os/linux/osContainer_linux.hpp
index 11c3e086feb..96b59b98db8 100644
--- a/src/hotspot/os/linux/osContainer_linux.hpp
+++ b/src/hotspot/os/linux/osContainer_linux.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -72,8 +72,7 @@ class OSContainer: AllStatic {
   static const char * container_type();
 
   static bool available_memory_in_bytes(physical_memory_size_type& value);
-  static bool available_swap_in_bytes(physical_memory_size_type host_free_swap,
-                                      physical_memory_size_type& value);
+  static bool available_swap_in_bytes(physical_memory_size_type& value);
   static bool memory_limit_in_bytes(physical_memory_size_type& value);
   static bool memory_and_swap_limit_in_bytes(physical_memory_size_type& value);
   static bool memory_and_swap_usage_in_bytes(physical_memory_size_type& value);
@@ -84,7 +83,7 @@ class OSContainer: AllStatic {
   static bool rss_usage_in_bytes(physical_memory_size_type& value);
   static bool cache_usage_in_bytes(physical_memory_size_type& value);
 
-  static bool active_processor_count(int& value);
+  static bool active_processor_count(double& value);
 
   static char * cpu_cpuset_cpus();
   static char * cpu_cpuset_memory_nodes();
diff --git a/src/hotspot/os/linux/os_linux.cpp b/src/hotspot/os/linux/os_linux.cpp
index 6a2a3974a16..48529c6ce17 100644
--- a/src/hotspot/os/linux/os_linux.cpp
+++ b/src/hotspot/os/linux/os_linux.cpp
@@ -211,15 +211,58 @@ static bool suppress_primordial_thread_resolution = false;
 
 // utility functions
 
+bool os::is_containerized() {
+  return OSContainer::is_containerized();
+}
+
+bool os::Container::memory_limit(physical_memory_size_type& value) {
+  physical_memory_size_type result = 0;
+  if (OSContainer::memory_limit_in_bytes(result) && result != value_unlimited) {
+    value = result;
+    return true;
+  }
+  return false;
+}
+
+bool os::Container::memory_soft_limit(physical_memory_size_type& value) {
+  physical_memory_size_type result = 0;
+  if (OSContainer::memory_soft_limit_in_bytes(result) && result != 0 && result != value_unlimited) {
+    value = result;
+    return true;
+  }
+  return false;
+}
+
+bool os::Container::memory_throttle_limit(physical_memory_size_type& value) {
+  physical_memory_size_type result = 0;
+  if (OSContainer::memory_throttle_limit_in_bytes(result) && result != value_unlimited) {
+    value = result;
+    return true;
+  }
+  return false;
+}
+
+bool os::Container::used_memory(physical_memory_size_type& value) {
+  return OSContainer::memory_usage_in_bytes(value);
+}
+
 bool os::available_memory(physical_memory_size_type& value) {
-  if (OSContainer::is_containerized() && OSContainer::available_memory_in_bytes(value)) {
+  if (is_containerized() && Container::available_memory(value)) {
     log_trace(os)("available container memory: " PHYS_MEM_TYPE_FORMAT, value);
     return true;
   }
 
+  return Machine::available_memory(value);
+}
+
+bool os::Machine::available_memory(physical_memory_size_type& value) {
   return Linux::available_memory(value);
 }
 
+bool os::Container::available_memory(physical_memory_size_type& value) {
+  return OSContainer::available_memory_in_bytes(value);
+}
+
 bool os::Linux::available_memory(physical_memory_size_type& value) {
   physical_memory_size_type avail_mem = 0;
 
@@ -251,11 +294,15 @@ bool os::Linux::available_memory(physical_memory_size_type& value) {
 }
 
 bool os::free_memory(physical_memory_size_type& value) {
-  if (OSContainer::is_containerized() && OSContainer::available_memory_in_bytes(value)) {
+  if (is_containerized() && Container::available_memory(value)) {
     log_trace(os)("free container memory: " PHYS_MEM_TYPE_FORMAT, value);
     return true;
   }
 
+  return Machine::free_memory(value);
+}
+
+bool os::Machine::free_memory(physical_memory_size_type& value) {
   return Linux::free_memory(value);
 }
 
@@ -274,21 +321,30 @@ bool os::Linux::free_memory(physical_memory_size_type& value) {
 }
 
 bool os::total_swap_space(physical_memory_size_type& value) {
-  if (OSContainer::is_containerized()) {
-    physical_memory_size_type mem_swap_limit = value_unlimited;
-    physical_memory_size_type memory_limit = value_unlimited;
-    if (OSContainer::memory_and_swap_limit_in_bytes(mem_swap_limit) &&
-        OSContainer::memory_limit_in_bytes(memory_limit)) {
-      if (memory_limit != value_unlimited && mem_swap_limit != value_unlimited &&
-          mem_swap_limit >= memory_limit /* ensure swap is >= 0 */) {
-        value = mem_swap_limit - memory_limit;
-        return true;
-      }
-    }
-  } // fallback to the host swap space if the container returned unlimited
+  if (is_containerized() && Container::total_swap_space(value)) {
+    return true;
+  } // fallback to the host swap space if the container value fails
+  return Machine::total_swap_space(value);
+}
+
+bool os::Machine::total_swap_space(physical_memory_size_type& value) {
   return Linux::host_swap(value);
 }
 
+bool os::Container::total_swap_space(physical_memory_size_type& value) {
+  physical_memory_size_type mem_swap_limit = value_unlimited;
+  physical_memory_size_type memory_limit = value_unlimited;
+  if (OSContainer::memory_and_swap_limit_in_bytes(mem_swap_limit) &&
+      OSContainer::memory_limit_in_bytes(memory_limit)) {
+    if (memory_limit != value_unlimited && mem_swap_limit != value_unlimited &&
+        mem_swap_limit >= memory_limit /* ensure swap is >= 0 */) {
+      value = mem_swap_limit - memory_limit;
+      return true;
+    }
+  }
+  return false;
+}
+
 static bool host_free_swap_f(physical_memory_size_type& value) {
   struct sysinfo si;
   int ret = sysinfo(&si);
@@ -309,32 +365,45 @@ bool os::free_swap_space(physical_memory_size_type& value) {
     return false;
   }
   physical_memory_size_type host_free_swap_val = MIN2(total_swap_space, host_free_swap);
-  if (OSContainer::is_containerized()) {
-    if (OSContainer::available_swap_in_bytes(host_free_swap_val, value)) {
+  if (is_containerized()) {
+    if (Container::free_swap_space(value)) {
       return true;
     }
     // Fall through to use host value
     log_trace(os,container)("os::free_swap_space: containerized value unavailable"
                             " returning host value: " PHYS_MEM_TYPE_FORMAT, host_free_swap_val);
   }
+
   value = host_free_swap_val;
   return true;
 }
 
+bool os::Machine::free_swap_space(physical_memory_size_type& value) {
+  return host_free_swap_f(value);
+}
+
+bool os::Container::free_swap_space(physical_memory_size_type& value) {
+  return OSContainer::available_swap_in_bytes(value);
+}
+
 physical_memory_size_type os::physical_memory() {
-  if (OSContainer::is_containerized()) {
+  if (is_containerized()) {
     physical_memory_size_type mem_limit = value_unlimited;
-    if (OSContainer::memory_limit_in_bytes(mem_limit) && mem_limit != value_unlimited) {
+    if (Container::memory_limit(mem_limit) && mem_limit != value_unlimited) {
       log_trace(os)("total container memory: " PHYS_MEM_TYPE_FORMAT, mem_limit);
       return mem_limit;
     }
   }
 
-  physical_memory_size_type phys_mem = Linux::physical_memory();
+  physical_memory_size_type phys_mem = Machine::physical_memory();
   log_trace(os)("total system memory: " PHYS_MEM_TYPE_FORMAT, phys_mem);
   return phys_mem;
 }
 
+physical_memory_size_type os::Machine::physical_memory() {
+  return Linux::physical_memory();
+}
+
 // Returns the resident set size (RSS) of the process.
 // Falls back to using VmRSS from /proc/self/status if /proc/self/smaps_rollup is unavailable.
 // Note: On kernels with memory cgroups or shared memory, VmRSS may underreport RSS.
@@ -2439,20 +2508,21 @@ bool os::Linux::print_container_info(outputStream* st) {
   OSContainer::print_container_metric(st, "cpu_memory_nodes", p != nullptr ? p : "not supported");
   free(p);
 
-  int i = -1;
-  bool supported = OSContainer::active_processor_count(i);
+  double cpus = -1;
+  bool supported = OSContainer::active_processor_count(cpus);
   if (supported) {
-    assert(i > 0, "must be");
+    assert(cpus > 0, "must be");
     if (ActiveProcessorCount > 0) {
       OSContainer::print_container_metric(st, "active_processor_count", ActiveProcessorCount, "(from -XX:ActiveProcessorCount)");
     } else {
-      OSContainer::print_container_metric(st, "active_processor_count", i);
+      OSContainer::print_container_metric(st, "active_processor_count", cpus);
     }
   } else {
     OSContainer::print_container_metric(st, "active_processor_count", "not supported");
   }
 
 
+  int i = -1;
   supported = OSContainer::cpu_quota(i);
   if (supported && i > 0) {
     OSContainer::print_container_metric(st, "cpu_quota", i);
@@ -4737,15 +4807,26 @@ int os::active_processor_count() {
     return ActiveProcessorCount;
   }
 
-  int active_cpus = -1;
-  if (OSContainer::is_containerized() && OSContainer::active_processor_count(active_cpus)) {
-    log_trace(os)("active_processor_count: determined by OSContainer: %d",
-                   active_cpus);
-  } else {
-    active_cpus = os::Linux::active_processor_count();
+  if (is_containerized()) {
+    double cpu_quota;
+    if (Container::processor_count(cpu_quota)) {
+      int active_cpus = ceilf(cpu_quota); // Round fractional CPU quota up.
+      assert(active_cpus <= Machine::active_processor_count(), "must be");
+      log_trace(os)("active_processor_count: determined by OSContainer: %d",
+                     active_cpus);
+      return active_cpus;
+    }
   }
 
-  return active_cpus;
+  return Machine::active_processor_count();
+}
+
+int os::Machine::active_processor_count() {
+  return os::Linux::active_processor_count();
+}
+
+bool os::Container::processor_count(double& value) {
+  return OSContainer::active_processor_count(value);
 }
 
 static bool should_warn_invalid_processor_id() {
diff --git a/src/hotspot/os/windows/os_windows.cpp b/src/hotspot/os/windows/os_windows.cpp
index efbd1fe7c68..b0b7ae18106 100644
--- a/src/hotspot/os/windows/os_windows.cpp
+++ b/src/hotspot/os/windows/os_windows.cpp
@@ -839,10 +839,18 @@ bool os::available_memory(physical_memory_size_type& value) {
   return win32::available_memory(value);
 }
 
+bool os::Machine::available_memory(physical_memory_size_type& value) {
+  return win32::available_memory(value);
+}
+
 bool os::free_memory(physical_memory_size_type& value) {
   return win32::available_memory(value);
 }
 
+bool os::Machine::free_memory(physical_memory_size_type& value) {
+  return win32::available_memory(value);
+}
+
 bool os::win32::available_memory(physical_memory_size_type& value) {
   // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect
   // value if total memory is larger than 4GB
@@ -858,7 +866,11 @@ bool os::win32::available_memory(physical_memory_size_type& value) {
   }
 }
 
-bool os::total_swap_space(physical_memory_size_type& value) {
+bool os::total_swap_space(physical_memory_size_type& value)  {
+  return Machine::total_swap_space(value);
+}
+
+bool os::Machine::total_swap_space(physical_memory_size_type& value) {
   MEMORYSTATUSEX ms;
   ms.dwLength = sizeof(ms);
   BOOL res = GlobalMemoryStatusEx(&ms);
@@ -872,6 +884,10 @@ bool os::total_swap_space(physical_memory_size_type& value) {
 }
 
 bool os::free_swap_space(physical_memory_size_type& value) {
+  return Machine::free_swap_space(value);
+}
+
+bool os::Machine::free_swap_space(physical_memory_size_type& value) {
   MEMORYSTATUSEX ms;
   ms.dwLength = sizeof(ms);
   BOOL res = GlobalMemoryStatusEx(&ms);
@@ -888,6 +904,10 @@ physical_memory_size_type os::physical_memory() {
   return win32::physical_memory();
 }
 
+physical_memory_size_type os::Machine::physical_memory() {
+  return win32::physical_memory();
+}
+
 size_t os::rss() {
   size_t rss = 0;
   PROCESS_MEMORY_COUNTERS_EX pmex;
@@ -911,6 +931,10 @@ int os::active_processor_count() {
     return ActiveProcessorCount;
   }
 
+  return Machine::active_processor_count();
+}
+
+int os::Machine::active_processor_count() {
   bool schedules_all_processor_groups = win32::is_windows_11_or_greater() || win32::is_windows_server_2022_or_greater();
   if (UseAllWindowsProcessorGroups && !schedules_all_processor_groups && !win32::processor_group_warning_displayed()) {
     win32::set_processor_group_warning_displayed(true);
diff --git a/src/hotspot/share/jfr/jni/jfrJniMethod.cpp b/src/hotspot/share/jfr/jni/jfrJniMethod.cpp
index d8a30f9b5ee..885484020bd 100644
--- a/src/hotspot/share/jfr/jni/jfrJniMethod.cpp
+++ b/src/hotspot/share/jfr/jni/jfrJniMethod.cpp
@@ -66,10 +66,6 @@
 #include "runtime/mutexLocker.hpp"
 #include "runtime/os.hpp"
 #include "utilities/debug.hpp"
-#ifdef LINUX
-#include "os_linux.hpp"
-#include "osContainer_linux.hpp"
-#endif
 
 #define NO_TRANSITION(result_type, header) extern "C" { result_type JNICALL header {
 #define NO_TRANSITION_END } }
@@ -400,35 +396,18 @@ JVM_ENTRY_NO_ENV(jboolean, jfr_is_class_instrumented(JNIEnv* env, jclass jvm, jc
 JVM_END
 
 JVM_ENTRY_NO_ENV(jboolean, jfr_is_containerized(JNIEnv* env, jclass jvm))
-#ifdef LINUX
-  return OSContainer::is_containerized();
-#else
-  return false;
-#endif
+  return os::is_containerized();
 JVM_END
 
 JVM_ENTRY_NO_ENV(jlong, jfr_host_total_memory(JNIEnv* env, jclass jvm))
-#ifdef LINUX
-  // We want the host memory, not the container limit.
-  // os::physical_memory() would return the container limit.
-  return static_cast<jlong>(os::Linux::physical_memory());
-#else
-  return static_cast<jlong>(os::physical_memory());
-#endif
+  return static_cast<jlong>(os::Machine::physical_memory());
 JVM_END
 
 JVM_ENTRY_NO_ENV(jlong, jfr_host_total_swap_memory(JNIEnv* env, jclass jvm))
-#ifdef LINUX
-  // We want the host swap memory, not the container value.
-  physical_memory_size_type host_swap = 0;
-  (void)os::Linux::host_swap(host_swap); // Discard return value and treat as no swap
-  return static_cast<jlong>(host_swap);
-#else
   physical_memory_size_type total_swap_space = 0;
   // Return value ignored - defaulting to 0 on failure.
-  (void)os::total_swap_space(total_swap_space);
+  (void)os::Machine::total_swap_space(total_swap_space);
   return static_cast<jlong>(total_swap_space);
-#endif
 JVM_END
 
 JVM_ENTRY_NO_ENV(void, jfr_emit_data_loss(JNIEnv* env, jclass jvm, jlong bytes))
diff --git a/src/hotspot/share/prims/jvm.cpp b/src/hotspot/share/prims/jvm.cpp
index ef5aca96a57..6d6937a97e9 100644
--- a/src/hotspot/share/prims/jvm.cpp
+++ b/src/hotspot/share/prims/jvm.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -115,9 +115,6 @@
 #if INCLUDE_MANAGEMENT
 #include "services/finalizerService.hpp"
 #endif
-#ifdef LINUX
-#include "osContainer_linux.hpp"
-#endif
 
 #include <errno.h>
 
@@ -500,11 +497,9 @@ JVM_LEAF(jboolean, JVM_IsUseContainerSupport(void))
 JVM_END
 
 JVM_LEAF(jboolean, JVM_IsContainerized(void))
-#ifdef LINUX
-  if (OSContainer::is_containerized()) {
+  if (os::is_containerized()) {
     return JNI_TRUE;
   }
-#endif
   return JNI_FALSE;
 JVM_END
 
diff --git a/src/hotspot/share/prims/whitebox.cpp b/src/hotspot/share/prims/whitebox.cpp
index 1c2f5527ff9..de5bc9ea58f 100644
--- a/src/hotspot/share/prims/whitebox.cpp
+++ b/src/hotspot/share/prims/whitebox.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -129,7 +129,6 @@
 #ifdef LINUX
 #include "cgroupSubsystem_linux.hpp"
 #include "os_linux.hpp"
-#include "osContainer_linux.hpp"
 #endif
 
 #define CHECK_JNI_EXCEPTION_(env, value)                               \
@@ -2582,14 +2581,12 @@ WB_ENTRY(jboolean, WB_CheckLibSpecifiesNoexecstack(JNIEnv* env, jobject o, jstri
 WB_END
 
 WB_ENTRY(jboolean, WB_IsContainerized(JNIEnv* env, jobject o))
-  LINUX_ONLY(return OSContainer::is_containerized();)
-  return false;
+  return os::is_containerized();
 WB_END
 
 // Physical memory of the host machine (including containers)
 WB_ENTRY(jlong, WB_HostPhysicalMemory(JNIEnv* env, jobject o))
-  LINUX_ONLY(return static_cast<jlong>(os::Linux::physical_memory());)
-  return static_cast<jlong>(os::physical_memory());
+  return static_cast<jlong>(os::Machine::physical_memory());
 WB_END
 
 // Available memory of the host machine (container-aware)
diff --git a/src/hotspot/share/runtime/os.cpp b/src/hotspot/share/runtime/os.cpp
index cf18388c625..1c06bf3c521 100644
--- a/src/hotspot/share/runtime/os.cpp
+++ b/src/hotspot/share/runtime/os.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -81,10 +81,6 @@
 #include "utilities/permitForbiddenFunctions.hpp"
 #include "utilities/powerOfTwo.hpp"
 
-#ifdef LINUX
-#include "osContainer_linux.hpp"
-#endif
-
 #ifndef _WINDOWS
 # include <poll.h>
 #endif
@@ -2205,11 +2201,14 @@ static void assert_nonempty_range(const char* addr, size_t bytes) {
 }
 
 bool os::used_memory(physical_memory_size_type& value) {
-#ifdef LINUX
-  if (OSContainer::is_containerized()) {
-    return OSContainer::memory_usage_in_bytes(value);
+  if (is_containerized()) {
+    return Container::used_memory(value);
   }
-#endif
+
+  return Machine::used_memory(value);
+}
+
+bool os::Machine::used_memory(physical_memory_size_type& value) {
   physical_memory_size_type avail_mem = 0;
   // Return value ignored - defaulting to 0 on failure.
   (void)os::available_memory(avail_mem);
@@ -2218,6 +2217,44 @@ bool os::used_memory(physical_memory_size_type& value) {
   return true;
 }
 
+#ifndef LINUX
+bool os::is_containerized() {
+  return false;
+}
+
+bool os::Container::processor_count(double& value) {
+  return false;
+}
+
+bool os::Container::available_memory(physical_memory_size_type& value) {
+  return false;
+}
+
+bool os::Container::used_memory(physical_memory_size_type& value) {
+  return false;
+}
+
+bool os::Container::total_swap_space(physical_memory_size_type& value) {
+  return false;
+}
+
+bool os::Container::free_swap_space(physical_memory_size_type& value) {
+  return false;
+}
+
+bool os::Container::memory_limit(physical_memory_size_type& value) {
+  return false;
+}
+
+bool os::Container::memory_soft_limit(physical_memory_size_type& value) {
+  return false;
+}
+
+bool os::Container::memory_throttle_limit(physical_memory_size_type& value) {
+  return false;
+}
+#endif
+
 
 bool os::commit_memory(char* addr, size_t bytes, bool executable) {
   assert_nonempty_range(addr, bytes);
diff --git a/src/hotspot/share/runtime/os.hpp b/src/hotspot/share/runtime/os.hpp
index d585d3e5fc0..29c872157fd 100644
--- a/src/hotspot/share/runtime/os.hpp
+++ b/src/hotspot/share/runtime/os.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -342,6 +342,52 @@ class os: AllStatic {
   static bool is_server_class_machine();
   static size_t rss();
 
+  // On platforms with container support (currently only Linux) we combine machine values with
+  // potential container values in os:: methods, abstracting which value is actually used.
+  // The os::Machine and os::Container classes and containing methods are used to get machine
+  // and container values (when available) separately.
+  static bool is_containerized();
+
+  // The os::Machine class reports system resource metrics from the perspective of the operating
+  // system, without considering container-imposed limits. The values returned by these methods
+  // reflect the resources visible to the process as reported by the OS, and may already be
+  // affected by mechanisms such as virtualization, hypervisor limits, or process affinity,
+  // but do NOT consider further restrictions imposed by container runtimes (e.g., cgroups)
+  class Machine : AllStatic {
+  public:
+    static int active_processor_count();
+
+    [[nodiscard]] static bool available_memory(physical_memory_size_type& value);
+    [[nodiscard]] static bool used_memory(physical_memory_size_type& value);
+    [[nodiscard]] static bool free_memory(physical_memory_size_type& value);
+
+    [[nodiscard]] static bool total_swap_space(physical_memory_size_type& value);
+    [[nodiscard]] static bool free_swap_space(physical_memory_size_type& value);
+
+    static physical_memory_size_type physical_memory();
+  };
+
+  // The os::Container class reports resource limits as imposed by a supported container runtime
+  // (currently only cgroup-based Linux runtimes). If the process is running inside a
+  // containerized environment, methods from this class report the effective limits imposed
+  // by the container, which may be more restrictive than what os::Machine reports.
+  // Methods return true and set the out-parameter if a limit is found,
+  // or false if no limit exists or it cannot be determined.
+  class Container : AllStatic {
+  public:
+    [[nodiscard]] static bool processor_count(double& value); // Returns the core-equivalent CPU quota
+
+    [[nodiscard]] static bool available_memory(physical_memory_size_type& value);
+    [[nodiscard]] static bool used_memory(physical_memory_size_type& value);
+
+    [[nodiscard]] static bool total_swap_space(physical_memory_size_type& value);
+    [[nodiscard]] static bool free_swap_space(physical_memory_size_type& value);
+
+    [[nodiscard]] static bool memory_limit(physical_memory_size_type& value);
+    [[nodiscard]] static bool memory_soft_limit(physical_memory_size_type& value);
+    [[nodiscard]] static bool memory_throttle_limit(physical_memory_size_type& value);
+  };
+
   // Returns the id of the processor on which the calling thread is currently executing.
   // The returned value is guaranteed to be between 0 and (os::processor_count() - 1).
   static uint processor_id();
diff --git a/test/hotspot/jtreg/containers/docker/TestCPUAwareness.java b/test/hotspot/jtreg/containers/docker/TestCPUAwareness.java
index 6b0a536e4d4..3064b320c0d 100644
--- a/test/hotspot/jtreg/containers/docker/TestCPUAwareness.java
+++ b/test/hotspot/jtreg/containers/docker/TestCPUAwareness.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -143,9 +143,9 @@ public class TestCPUAwareness {
 
 
     // Expected active processor count can not exceed available CPU count
-    private static int adjustExpectedAPCForAvailableCPUs(int expectedAPC) {
-        if (expectedAPC > availableCPUs) {
-            expectedAPC = availableCPUs;
+    private static double adjustExpectedAPCForAvailableCPUs(double expectedAPC) {
+        if (expectedAPC > (double)availableCPUs) {
+            expectedAPC = (double)availableCPUs;
             System.out.println("Adjusted expectedAPC = " + expectedAPC);
         }
         return expectedAPC;
@@ -158,7 +158,7 @@ public class TestCPUAwareness {
         System.out.println("quota = " + quota);
         System.out.println("period = " + period);
 
-        int expectedAPC = (int) Math.ceil((float) quota / (float) period);
+        double expectedAPC = (double) quota / (double) period;
         System.out.println("expectedAPC = " + expectedAPC);
         expectedAPC = adjustExpectedAPCForAvailableCPUs(expectedAPC);
 
@@ -178,7 +178,7 @@ public class TestCPUAwareness {
 
 
     private static void testAPCCombo(String cpuset, int quota, int period, int shares,
-                                     int expectedAPC) throws Exception {
+                                     double expectedAPC) throws Exception {
         Common.logNewTestCase("test APC Combo");
         System.out.println("cpuset = " + cpuset);
         System.out.println("quota = " + quota);