summaryrefslogtreecommitdiff
path: root/indra/llcommon/llmemory.cpp
blob: ba48319a162faa42fcd391d2b8a38c020fa1b487 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
/**
 * @file llmemory.cpp
 * @brief Very special memory allocation/deallocation stuff here
 *
 * $LicenseInfo:firstyear=2002&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "linden_common.h"


#include "llthread.h"

#if defined(LL_WINDOWS)
# include <psapi.h>
#elif defined(LL_DARWIN)
# include <sys/types.h>
# include <mach/task.h>
# include <mach/mach_init.h>
#include <mach/mach_host.h>
#elif LL_LINUX
# include <unistd.h>
# include <sys/resource.h>
# include <sys/sysinfo.h>
#endif

#include "llmemory.h"

#include "llsys.h"
#include "llframetimer.h"
#include "lltrace.h"
#include "llerror.h"
//----------------------------------------------------------------------------

//static

// most important memory metric for texture streaming
//  On Windows, this should agree with resource monitor -> performance -> memory -> available
//  On OS X, this should be activity monitor -> memory -> (physical memory - memory used)
// NOTE: this number MAY be less than the actual available memory on systems with more than MaxHeapSize64 GB of physical memory (default 16GB)
//  In that case, should report min(available, sMaxHeapSizeInKB-sAllocateMemInKB)
U32Kilobytes LLMemory::sAvailPhysicalMemInKB(U32_MAX);

// Installed physical memory
U32Kilobytes LLMemory::sMaxPhysicalMemInKB(0);

// Maximimum heap size according to the user's settings (default 16GB)
U32Kilobytes LLMemory::sMaxHeapSizeInKB(U32_MAX);

// Current memory usage
U32Kilobytes LLMemory::sAllocatedMemInKB(0);

U32Kilobytes LLMemory::sAllocatedPageSizeInKB(0);


static LLTrace::SampleStatHandle<F64Megabytes> sAllocatedMem("allocated_mem", "active memory in use by application");
static LLTrace::SampleStatHandle<F64Megabytes> sVirtualMem("virtual_mem", "virtual memory assigned to application");

void ll_assert_aligned_func(uintptr_t ptr,U32 alignment)
{
#if defined(LL_WINDOWS) && defined(LL_DEBUG_BUFFER_OVERRUN)
    //do not check
    return;
#else
    #ifdef SHOW_ASSERT
        // Redundant, place to set breakpoints.
        if (ptr%alignment!=0)
        {
            LL_WARNS() << "alignment check failed" << LL_ENDL;
        }
        llassert(ptr%alignment==0);
    #endif
#endif
}

//static
void LLMemory::initMaxHeapSizeGB(F32Gigabytes max_heap_size)
{
    sMaxHeapSizeInKB = U32Kilobytes::convert(max_heap_size);
}

//static
void LLMemory::updateMemoryInfo()
{
    LL_PROFILE_ZONE_SCOPED;

    sMaxPhysicalMemInKB = gSysMemory.getPhysicalMemoryKB();

    U32Kilobytes avail_mem;
    LLMemoryInfo::getAvailableMemoryKB(avail_mem);
    sAvailPhysicalMemInKB = avail_mem;

#if LL_WINDOWS
    PROCESS_MEMORY_COUNTERS counters;

    if (!GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters)))
    {
        LL_WARNS() << "GetProcessMemoryInfo failed" << LL_ENDL;
        return ;
    }

    sAllocatedMemInKB = U32Kilobytes::convert(U64Bytes(counters.WorkingSetSize));
    sAllocatedPageSizeInKB = U32Kilobytes::convert(U64Bytes(counters.PagefileUsage));
    sample(sVirtualMem, sAllocatedPageSizeInKB);

#elif defined(LL_DARWIN)
    task_vm_info info;
    mach_msg_type_number_t  infoCount = TASK_VM_INFO_COUNT;
    // MACH_TASK_BASIC_INFO reports the same resident_size, but does not tell us the reusable bytes or phys_footprint.
    if (task_info(mach_task_self(), TASK_VM_INFO, reinterpret_cast<task_info_t>(&info), &infoCount) == KERN_SUCCESS)
    {
        // Our Windows definition of PagefileUsage is documented by Microsoft as "the total amount of
        // memory that the memory manager has committed for a running process", which is rss.
        sAllocatedPageSizeInKB = U32Kilobytes::convert(U64Bytes(info.resident_size));

        // Activity Monitor => Inspect Process => Real Memory Size appears to report resident_size
        // Activity monitor => main window memory column appears to report phys_footprint, which spot checks as at least 30% less.
        //        I think that is because of compression, which isn't going to give us a consistent measurement. We want uncompressed totals.
        //
        // In between is resident_size - reusable. This is what Chrome source code uses, with source comments saying it is 'the "Real Memory" value
        // reported for the app by the Memory Monitor in Instruments.' It is still about 8% bigger than phys_footprint.
        //
        // (On Windows, we use WorkingSetSize.)
        sAllocatedMemInKB = U32Kilobytes::convert(U64Bytes(info.resident_size - info.reusable));
     }
    else
    {
        LL_WARNS() << "task_info failed" << LL_ENDL;
    }
#elif defined(LL_LINUX)
    // Use sysinfo() to get the total physical memory.
    struct sysinfo info;
    sysinfo(&info);
    sAllocatedMemInKB = U32Kilobytes::convert(U64Bytes(LLMemory::getCurrentRSS())); // represents the RAM allocated by this process only (in line with the windows implementation)
#else
    //not valid for other systems for now.
    LL_WARNS() << "LLMemory::updateMemoryInfo() not implemented for this platform." << LL_ENDL;
    sAllocatedMemInKB = U64Bytes(LLMemory::getCurrentRSS());
#endif
    sample(sAllocatedMem, sAllocatedMemInKB);

    sAvailPhysicalMemInKB = llmin(sAvailPhysicalMemInKB, sMaxHeapSizeInKB - sAllocatedMemInKB);

    return ;
}

//
//this function is to test if there is enough space with the size in the virtual address space.
//it does not do any real allocation
//if success, it returns the address where the memory chunk can fit in;
//otherwise it returns NULL.
//
//static
void* LLMemory::tryToAlloc(void* address, U32 size)
{
#if LL_WINDOWS
    address = VirtualAlloc(address, size, MEM_RESERVE | MEM_TOP_DOWN, PAGE_NOACCESS) ;
    if(address)
    {
        if(!VirtualFree(address, 0, MEM_RELEASE))
        {
            LL_ERRS() << "error happens when free some memory reservation." << LL_ENDL ;
        }
    }
    return address ;
#else
    return (void*)0x01 ; //skip checking
#endif
}

//static
void LLMemory::logMemoryInfo(bool update)
{
    LL_PROFILE_ZONE_SCOPED;
    if(update)
    {
        updateMemoryInfo() ;
    }

    LL_INFOS() << llformat("Current allocated physical memory: %.2f MB", sAllocatedMemInKB / 1024.0) << LL_ENDL;
    LL_INFOS() << llformat("Current allocated page size: %.2f MB", sAllocatedPageSizeInKB / 1024.0) << LL_ENDL;
    LL_INFOS() << llformat("Current available physical memory: %.2f MB", sAvailPhysicalMemInKB / 1024.0) << LL_ENDL;
    LL_INFOS() << llformat("Current max usable memory: %.2f MB", sMaxPhysicalMemInKB / 1024.0) << LL_ENDL;
}

//static
U32Kilobytes LLMemory::getAvailableMemKB()
{
    return sAvailPhysicalMemInKB ;
}

//static
U32Kilobytes LLMemory::getMaxMemKB()
{
    return sMaxPhysicalMemInKB ;
}

//static
U32Kilobytes LLMemory::getAllocatedMemKB()
{
    return sAllocatedMemInKB ;
}

//----------------------------------------------------------------------------

#if defined(LL_WINDOWS)

//static
U64 LLMemory::getCurrentRSS()
{
    PROCESS_MEMORY_COUNTERS counters;

    if (!GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters)))
    {
        LL_WARNS() << "GetProcessMemoryInfo failed" << LL_ENDL;
        return 0;
    }

    return counters.WorkingSetSize;
}

#elif defined(LL_DARWIN)

//  if (sysctl(ctl, 2, &page_size, &size, NULL, 0) == -1)
//  {
//      LL_WARNS() << "Couldn't get page size" << LL_ENDL;
//      return 0;
//  } else {
//      return page_size;
//  }
// }

U64 LLMemory::getCurrentRSS()
{
    U64 residentSize = 0;
    mach_task_basic_info_data_t basicInfo;
    mach_msg_type_number_t  basicInfoCount = MACH_TASK_BASIC_INFO_COUNT;
    if (task_info(mach_task_self(), MACH_TASK_BASIC_INFO, (task_info_t)&basicInfo, &basicInfoCount) == KERN_SUCCESS)
    {
        residentSize = basicInfo.resident_size;
        // 64-bit macos apps allocate 32 GB or more at startup, and this is reflected in virtual_size.
        // basicInfo.virtual_size is not what we want.
    }
    else
    {
        LL_WARNS() << "task_info failed" << LL_ENDL;
    }

    return residentSize;
}

#elif defined(LL_LINUX)

U64 LLMemory::getCurrentRSS()
{
    struct rusage usage;

    if (getrusage(RUSAGE_SELF, &usage) != 0) {
        // Error handling code could be here
        return 0;
    }

    // ru_maxrss (since Linux 2.6.32)
    // This is the maximum resident set size used (in kilobytes).
    return usage.ru_maxrss * 1024;
}

#else

U64 LLMemory::getCurrentRSS()
{
    return 0;
}

#endif

//--------------------------------------------------------------------

#if defined(LL_WINDOWS) && defined(LL_DEBUG_BUFFER_OVERRUN)

#include <map>

struct mem_info {
    std::map<void*, void*> memory_info;
    LLMutex mutex;

    static mem_info& get() {
        static mem_info instance;
        return instance;
    }

private:
    mem_info(){}
};

void* ll_aligned_malloc_fallback( size_t size, int align )
{
    SYSTEM_INFO sysinfo;
    GetSystemInfo(&sysinfo);

    unsigned int for_alloc = (size/sysinfo.dwPageSize + !!(size%sysinfo.dwPageSize)) * sysinfo.dwPageSize;

    void *p = VirtualAlloc(NULL, for_alloc+sysinfo.dwPageSize, MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE);
    if(NULL == p) {
        // call debugger
        __asm int 3;
    }
    DWORD old;
    bool Res = VirtualProtect((void*)((char*)p + for_alloc), sysinfo.dwPageSize, PAGE_NOACCESS, &old);
    if(false == Res) {
        // call debugger
        __asm int 3;
    }

    void* ret = (void*)((char*)p + for_alloc-size);

    {
        LLMutexLock lock(&mem_info::get().mutex);
        mem_info::get().memory_info.insert(std::pair<void*, void*>(ret, p));
    }


    return ret;
}

void ll_aligned_free_fallback( void* ptr )
{
    LLMutexLock lock(&mem_info::get().mutex);
    VirtualFree(mem_info::get().memory_info.find(ptr)->second, 0, MEM_RELEASE);
    mem_info::get().memory_info.erase(ptr);
}

#endif