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#ifndef BASE_MEMORY_DISCARDABLE_MEMORY_ASHMEM_ALLOCATOR_H_
6#define BASE_MEMORY_DISCARDABLE_MEMORY_ASHMEM_ALLOCATOR_H_
7
8#include <string>
9
10#include "base/base_export.h"
11#include "base/basictypes.h"
12#include "base/memory/scoped_ptr.h"
13#include "base/memory/scoped_vector.h"
14#include "base/synchronization/lock.h"
15
16namespace base {
17namespace internal {
18
19class AshmemRegion;
20
21// Internal class, whose instances are returned to the client of the allocator
22// (e.g. DiscardableMemoryAshmem), that mimicks the DiscardableMemory interface.
23class BASE_EXPORT_PRIVATE DiscardableAshmemChunk {
24 public:
25  ~DiscardableAshmemChunk();
26
27  // Returns whether the memory is still resident.
28  bool Lock();
29
30  void Unlock();
31
32  void* Memory() const;
33
34 private:
35  friend class AshmemRegion;
36
37  DiscardableAshmemChunk(AshmemRegion* ashmem_region,
38                         int fd,
39                         void* address,
40                         size_t offset,
41                         size_t size);
42
43  AshmemRegion* const ashmem_region_;
44  const int fd_;
45  void* const address_;
46  const size_t offset_;
47  const size_t size_;
48  bool locked_;
49
50  DISALLOW_COPY_AND_ASSIGN(DiscardableAshmemChunk);
51};
52
53// Ashmem regions are backed by a file (descriptor) therefore they are a limited
54// resource. This allocator minimizes the problem by allocating large ashmem
55// regions internally and returning smaller chunks to the client.
56// Allocated chunks are systematically aligned on a page boundary therefore this
57// allocator should not be used for small allocations.
58class BASE_EXPORT_PRIVATE DiscardableMemoryAshmemAllocator {
59 public:
60  // Note that |name| is only used for debugging/measurement purposes.
61  // |ashmem_region_size| is the size that will be used to create the underlying
62  // ashmem regions and is expected to be greater or equal than 32 MBytes.
63  DiscardableMemoryAshmemAllocator(const std::string& name,
64                                   size_t ashmem_region_size);
65
66  ~DiscardableMemoryAshmemAllocator();
67
68  // Note that the allocator must outlive the returned DiscardableAshmemChunk
69  // instance.
70  scoped_ptr<DiscardableAshmemChunk> Allocate(size_t size);
71
72  // Returns the size of the last ashmem region which was created. This is used
73  // for testing only.
74  size_t last_ashmem_region_size() const;
75
76 private:
77  friend class AshmemRegion;
78
79  void DeleteAshmemRegion_Locked(AshmemRegion* region);
80
81  const std::string name_;
82  const size_t ashmem_region_size_;
83  mutable Lock lock_;
84  size_t last_ashmem_region_size_;
85  ScopedVector<AshmemRegion> ashmem_regions_;
86
87  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryAshmemAllocator);
88};
89
90}  // namespace internal
91}  // namespace base
92
93#endif  // BASE_MEMORY_DISCARDABLE_MEMORY_ASHMEM_ALLOCATOR_H_
94