09eb17355b9420edcfb0ce72a03929d0c6691bb6
[WebKit.git] / Source / bmalloc / bmalloc / Sizes.h
1 /*
2  * Copyright (C) 2014 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef Sizes_h
27 #define Sizes_h
28
29 #include "Algorithm.h"
30 #include "BPlatform.h"
31 #include <algorithm>
32 #include <cstdint>
33 #include <cstddef>
34 #include <limits>
35 #include <type_traits>
36 #include <chrono>
37
38 namespace bmalloc {
39
40 // Repository for malloc sizing constants and calculations.
41
42 namespace Sizes {
43     static const size_t kB = 1024;
44     static const size_t MB = kB * kB;
45
46     static const size_t alignment = 8;
47     static const size_t alignmentMask = alignment - 1ul;
48
49     static const size_t chunkSize = 2 * MB;
50     static const size_t chunkMask = ~(chunkSize - 1ul);
51
52     static const size_t smallLineSize = 256;
53     static const size_t smallPageSize = 4 * kB;
54     static const size_t smallPageLineCount = smallPageSize / smallLineSize;
55
56     static const size_t maskSizeClassMax = 512;
57     static const size_t smallMax = 32 * kB;
58
59     static const size_t pageSizeMax = smallMax * 2;
60     static const size_t pageClassCount = pageSizeMax / smallPageSize;
61
62     static const size_t pageSizeWasteFactor = 8;
63     static const size_t logWasteFactor = 8;
64
65     static const size_t largeAlignment = smallMax / pageSizeWasteFactor;
66     static const size_t largeAlignmentMask = largeAlignment - 1;
67
68     static const size_t deallocatorLogCapacity = 512;
69     static const size_t bumpRangeCacheCapacity = 3;
70     
71     static const size_t scavengerBytesPerMemoryPressureCheck = 16 * MB;
72     static const double memoryPressureThreshold = 0.75;
73     
74     static const std::chrono::milliseconds asyncTaskSleepDuration = std::chrono::milliseconds(2000);
75     
76     static const size_t maskSizeClassCount = maskSizeClassMax / alignment;
77
78     inline constexpr size_t maskSizeClass(size_t size)
79     {
80         // We mask to accommodate zero.
81         return mask((size - 1) / alignment, maskSizeClassCount - 1);
82     }
83
84     inline size_t maskObjectSize(size_t maskSizeClass)
85     {
86         return (maskSizeClass + 1) * alignment;
87     }
88
89     static const size_t logAlignmentMin = maskSizeClassMax / logWasteFactor;
90
91     static const size_t logSizeClassCount = (log2(smallMax) - log2(maskSizeClassMax)) * logWasteFactor;
92
93     inline size_t logSizeClass(size_t size)
94     {
95         size_t base = log2(size - 1) - log2(maskSizeClassMax);
96         size_t offset = (size - 1 - (maskSizeClassMax << base));
97         return base * logWasteFactor + offset / (logAlignmentMin << base);
98     }
99
100     inline size_t logObjectSize(size_t logSizeClass)
101     {
102         size_t base = logSizeClass / logWasteFactor;
103         size_t offset = logSizeClass % logWasteFactor;
104         return (maskSizeClassMax << base) + (offset + 1) * (logAlignmentMin << base);
105     }
106
107     static const size_t sizeClassCount = maskSizeClassCount + logSizeClassCount;
108
109     inline size_t sizeClass(size_t size)
110     {
111         if (size <= maskSizeClassMax)
112             return maskSizeClass(size);
113         return maskSizeClassCount + logSizeClass(size);
114     }
115
116     inline size_t objectSize(size_t sizeClass)
117     {
118         if (sizeClass < maskSizeClassCount)
119             return maskObjectSize(sizeClass);
120         return logObjectSize(sizeClass - maskSizeClassCount);
121     }
122     
123     inline size_t pageSize(size_t pageClass)
124     {
125         return (pageClass + 1) * smallPageSize;
126     }
127 }
128
129 using namespace Sizes;
130
131 } // namespace bmalloc
132
133 #endif // Sizes_h