Home | History | Annotate | Download | only in delegate 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "athena/resource_manager/public/resource_manager_delegate.h"
      6 
      7 #include <string>
      8 
      9 #include "base/logging.h"
     10 #include "base/macros.h"
     11 #include "base/process/process_metrics.h"
     12 
     13 namespace athena {
     14 
     15 namespace {
     16 // This is the minimum amount of time in milliseconds between checks for
     17 // memory pressure.
     18 const int kMemoryPressureIntervalMs = 750;
     19 }  // namespace
     20 
     21 class ResourceManagerDelegateImpl : public ResourceManagerDelegate {
     22  public:
     23   ResourceManagerDelegateImpl() {}
     24   virtual ~ResourceManagerDelegateImpl() {}
     25 
     26  private:
     27   virtual int GetUsedMemoryInPercent() OVERRIDE {
     28     base::SystemMemoryInfoKB info;
     29     if (!base::GetSystemMemoryInfo(&info)) {
     30       LOG(WARNING) << "Cannot determine the free memory of the system.";
     31       return 0;
     32     }
     33     // TODO(skuhne): Instead of adding the kernel memory pressure calculation
     34     // logic here, we should have a kernel mechanism similar to the low memory
     35     // notifier in ChromeOS which offers multiple pressure states.
     36     // To track this, we have crbug.com/381196.
     37 
     38     // The available memory consists of "real" and virtual (z)ram memory.
     39     // Since swappable memory uses a non pre-deterministic compression and
     40     // the compression creates its own "dynamic" in the system, it gets
     41     // de-emphasized by the |kSwapWeight| factor.
     42     const int kSwapWeight = 4;
     43 
     44     // The total memory we have is the "real memory" plus the virtual (z)ram.
     45     int total_memory = info.total + info.swap_total / kSwapWeight;
     46 
     47     // The kernel internally uses 50MB.
     48     const int kMinFileMemory = 50 * 1024;
     49 
     50     // Most file memory can be easily reclaimed.
     51     int file_memory = info.active_file + info.inactive_file;
     52     // unless it is dirty or it's a minimal portion which is required.
     53     file_memory -= info.dirty + kMinFileMemory;
     54 
     55     // Available memory is the sum of free, swap and easy reclaimable memory.
     56     int available_memory =
     57         info.free + info.swap_free / kSwapWeight + file_memory;
     58 
     59     DCHECK(available_memory < total_memory);
     60     int percentage = ((total_memory - available_memory) * 100) / total_memory;
     61     return percentage;
     62   }
     63 
     64   virtual int MemoryPressureIntervalInMS() OVERRIDE {
     65     return kMemoryPressureIntervalMs;
     66   }
     67   DISALLOW_COPY_AND_ASSIGN(ResourceManagerDelegateImpl);
     68 };
     69 
     70 // static
     71 ResourceManagerDelegate*
     72 ResourceManagerDelegate::CreateResourceManagerDelegate() {
     73   return new ResourceManagerDelegateImpl;
     74 }
     75 
     76 }  // namespace athena
     77