TIMING Large Alloc 2  : 808.40 ms -  1.27 us (825.00 ms / 636928 ), min:  0.00 ns, max: 17.00 ms, nesting: 0 - 636928
TIMING Large Alloc    :  1.97 s  - 167.81 ns ( 2.27 s  / 11734322 ), min:  0.00 ns, max: 28.00 ms, nesting: 0 - 11734325

error: use of undeclared identifier 'MemoryTryRealloc'

in function `Upp::sProfile(Upp::MemoryProfile const&)':
/home/ssg/dvlp/cpp/upp/git/uppsrc/CtrlLib/CtrlUtil.cpp:368: undefined reference to `Upp::AsString(Upp::MemoryProfile const&)'

namespace Upp {
	
struct MemInspector {
protected:
	static bool active;

	const char *name;
	int         call_count;
	int         min_mem;
	int         max_mem;
	int         max_nesting;
	int         all_count;
	StaticMutex mutex;

public:
	MemInspector(const char *name = NULL); // Not String !!!
	~MemInspector();

	void Add(int mem, int nesting);

	String Dump();

	class Routine {
	public:
		Routine(MemInspector& stat, int& nesting)
		: nesting(nesting), stat(stat) {
			++nesting;
		}

		~Routine() {
			--nesting;
			int mem = MemoryUsedKb();
			stat.Add(mem, nesting);
		}

	protected:
		int& nesting;
		MemInspector& stat;
	};

	static void Activate(bool b) { active = b; }
};

bool MemInspector::active = true;

MemInspector::MemInspector(const char *_name) {
	name = _name ? _name : "";
	all_count = call_count = max_nesting = min_mem = max_mem = 0;
}

MemInspector::~MemInspector() {
	Mutex::Lock __(mutex);
	StdLog() << Dump() << "\r\n";
}

void MemInspector::Add(int mem, int nesting)
{
	// mem = MemoryUsedKb() - mem;
	Mutex::Lock __(mutex);
	if(!active) return;
	all_count++;
	if(nesting > max_nesting)
		max_nesting = nesting;
	if(nesting == 0) {
		if(call_count++ == 0)
			min_mem = max_mem = mem;
		else {
			if(mem < min_mem)
				min_mem = mem;
			if(mem > max_mem)
				max_mem = mem;
		}
	}
}

String MemInspector::Dump() {
	Mutex::Lock __(mutex);
	String s = Sprintf("MEMUSE %-15s: ", name);
	if(call_count == 0)
		return s + "No active hit";
	return s
		   << "min: " << min_mem
		   << ", max: " << max_mem
		   << Sprintf(", nesting: %d - %d", max_nesting, all_count);
}


}

#define RMEMUSE(x) \
	static UPP::MemInspector COMBINE(sMemStat, __LINE__)(x); \
	static thread_local int COMBINE(sMemStatNesting, __LINE__); \
	UPP::MemInspector::Routine COMBINE(sMemStatR, __LINE__)(COMBINE(sMemStat, __LINE__), COMBINE(sMemStatNesting, __LINE__))

TIMING Chunk          : 4108.80 s  - 22.66 ms (4108.80 s  / 181363 ), min:  1.00 ms, max:  1.24 s , nesting: 0 - 181363
MEMUSE Chunk          : min: 30844, max: 341052, nesting: 0 - 181363
TIMING Read Data      : 228.28 s  - 228.28 s  (228.28 s  / 1 ), min: 228.28 s , max: 228.28 s , nesting: 0 - 1

*PeakMemoryProfile() = Memory peak 328920
  32 B,      13 allocated (     0 KB),    113 fragments (     3 KB)
  64 B,       8 allocated (     0 KB),     55 fragments (     3 KB)
  96 B,       6 allocated (     0 KB),     36 fragments (     3 KB)
 128 B,       3 allocated (     0 KB),     28 fragments (     3 KB)
 160 B,       3 allocated (     0 KB),     22 fragments (     3 KB)
 192 B,       2 allocated (     0 KB),     19 fragments (     3 KB)
 224 B,       3 allocated (     0 KB),     15 fragments (     3 KB)
 256 B,       2 allocated (     0 KB),     13 fragments (     3 KB)
 288 B,       2 allocated (     0 KB),     12 fragments (     3 KB)
 320 B,       2 allocated (     0 KB),     10 fragments (     3 KB)
 352 B,       1 allocated (     0 KB),     10 fragments (     3 KB)
 384 B,       2 allocated (     0 KB),      8 fragments (     3 KB)
 448 B,       2 allocated (     0 KB),      7 fragments (     3 KB)
 576 B,       4 allocated (     2 KB),      3 fragments (     1 KB)
 672 B,       3 allocated (     1 KB),      3 fragments (     1 KB)
 800 B,       2 allocated (     1 KB),      3 fragments (     2 KB)
 992 B,       3 allocated (     2 KB),      1 fragments (     0 KB)
 TOTAL,      61 allocated (    15 KB),    358 fragments (    50 KB)
Empty 4KB pages 0 (0 KB)
Large block count 9, total size 119 KB
Large fragments count 5, total size 71 KB
Huge block count 80, total size 1779376 KB
Sys block count 0, total size 0 KB
224MB master blocks 4

Large fragments:
1 KB: 1
8 KB: 1
17.25 KB: 1
22 KB: 1
23.5 KB: 1

Huge fragments:
8 KB: 1
16 KB: 1
20 KB: 3
32 KB: 5
36 KB: 2
40 KB: 1
44 KB: 1
52 KB: 1
64 KB: 20
68 KB: 1
80 KB: 6
92 KB: 2
120 KB: 1
128 KB: 1
144 KB: 1
156 KB: 1
164 KB: 1
180 KB: 2
188 KB: 2
192 KB: 3
196 KB: 1
204 KB: 1
248 KB: 1
252 KB: 1
272 KB: 2
276 KB: 1
284 KB: 1
288 KB: 1
296 KB: 2
304 KB: 1
320 KB: 1
328 KB: 1
348 KB: 1
364 KB: 1
384 KB: 1
396 KB: 2
412 KB: 1
440 KB: 1
464 KB: 1
468 KB: 1
484 KB: 1
500 KB: 1
504 KB: 1
512 KB: 1
520 KB: 1
560 KB: 2
564 KB: 1
568 KB: 1
576 KB: 1
580 KB: 1
612 KB: 1
616 KB: 1
620 KB: 1
640 KB: 1
652 KB: 2
696 KB: 1
700 KB: 1
708 KB: 1
740 KB: 1
760 KB: 1
780 KB: 1
784 KB: 1
796 KB: 1
916 KB: 1
944 KB: 1
972 KB: 1
1044 KB: 1
1084 KB: 1
1088 KB: 1
1148 KB: 1
1184 KB: 1
1200 KB: 1
1212 KB: 1
1216 KB: 1
1272 KB: 1
1280 KB: 1
1300 KB: 1
1364 KB: 1
1464 KB: 1
1512 KB: 1
1616 KB: 1
1716 KB: 1
1720 KB: 1
1920 KB: 1
1996 KB: 1
2220 KB: 1
2280 KB: 1
2552 KB: 1
2576 KB: 1
2596 KB: 1
2804 KB: 1
2864 KB: 1
3080 KB: 1
3324 KB: 1
3420 KB: 1
3516 KB: 3
3580 KB: 6
3596 KB: 1
3644 KB: 1
3648 KB: 1
3916 KB: 1
4408 KB: 1
4452 KB: 1
4720 KB: 1
5564 KB: 1
5632 KB: 1
6996 KB: 1
7036 KB: 1
7100 KB: 1
7280 KB: 2
7632 KB: 1
7848 KB: 1
7864 KB: 1
8344 KB: 1
8448 KB: 1
8632 KB: 1
8820 KB: 1
8968 KB: 1
9124 KB: 1
9296 KB: 1
9440 KB: 1
9880 KB: 1
10612 KB: 1
10768 KB: 1
11136 KB: 1
11188 KB: 1
11420 KB: 1
13572 KB: 1
14304 KB: 1
14988 KB: 1
15168 KB: 1
15576 KB: 1
15924 KB: 1
16040 KB: 1
18012 KB: 1
19204 KB: 1
20108 KB: 1
20396 KB: 1
55160 KB: 1

bool  MemoryTryRealloc(void *ptr, size_t& newsize) {
	return false; // (((dword)(uintptr_t)ptr) & 16) && MemoryTryRealloc__(ptr, newsize);
}

void *Heap::HugeAlloc(size_t count) // count in 4kb pages
{
	ASSERT(count);

#ifdef LSTAT
	if(count < 65536)
		hstat[count]++;
#endif

	huge_4KB_count += count;
	
	if(huge_4KB_count > huge_4KB_count_max) {
		huge_4KB_count_max = huge_4KB_count;
		if(MemoryUsedKb() > sKBLimit)
			Panic("MemoryLimitKb breached!");
		if(sPeak)
			Make(*sPeak);
	}

	if(!D::freelist[0]->next) { // initialization
		for(int i = 0; i < 2; i++)
			Dbl_Self(D::freelist[i]);
	}
		
	if(count > HPAGE) { // we are wasting 4KB to store just 4 bytes here, but this is >32MB after all..
		LTIMING("SysAlloc");
		byte *sysblk = (byte *)SysAllocRaw((count + 1) * 4096, 0);
		BlkHeader *h = (BlkHeader *)(sysblk + 4096);
		h->size = 0;
		*((size_t *)sysblk) = count;
		sys_count++;
		sys_size += 4096 * count;
		return h;
	}
	
	LTIMING("Huge Alloc");

	word wcount = (word)count;
	
	if(16 * free_4KB > huge_4KB_count) // keep number of free 4KB blocks in check
		FreeSmallEmpty(INT_MAX, int(free_4KB - huge_4KB_count / 32));
	
	for(int pass = 0; pass < 2; pass++) {
		for(int i = count >= 16; i < 2; i++) {
			BlkHeader *l = D::freelist[i];
			BlkHeader *h = l->next;
			while(h != l) {
				word sz = h->GetSize();
				if(sz >= count) {
					void *ptr = MakeAlloc(h, wcount);
					if(count > 16)
						RLOG("HugeAlloc " << asString(ptr) << ", size: " << asString(count));
					return ptr;
				}
				h = h->next;
			}
		}

		if(!FreeSmallEmpty(wcount, INT_MAX)) { // try to coalesce 4KB small free blocks back to huge storage
			void *ptr = SysAllocRaw(HPAGE * 4096, 0);
			HugePage *pg = (HugePage *)MemoryAllocPermanent(sizeof(HugePage));
			pg->page = ptr;
			pg->next = huge_pages;
			huge_pages = pg;
			AddChunk((BlkHeader *)ptr, HPAGE); // failed, add 32MB from the system
			huge_chunks++;
		}
	}
	Panic("Out of memory");
	return NULL;
}

int Heap::HugeFree(void *ptr)
{
	BlkHeader *h = (BlkHeader *)ptr;
	if(h->size == 0) {
		LTIMING("Sys Free");
		byte *sysblk = (byte *)h - 4096;
		size_t count = *((size_t *)sysblk);
		SysFreeRaw(sysblk, (count + 1) * 4096);
		huge_4KB_count -= count;
		sys_count--;
		sys_size -= 4096 * count;
		return 0;
	}
	LTIMING("Huge Free");
	if(h->GetSize() > 16)
		RLOG("HugeFree " << asString(ptr) << ", size: " << asString(h->GetSize()));
	huge_4KB_count -= h->GetSize();
	return BlkHeap::Free(h)->GetSize();
}

bool Heap::HugeTryRealloc(void *ptr, size_t count)
{
	bool b = count <= HPAGE && BlkHeap::TryRealloc(ptr, count, huge_4KB_count);
	if(b)
		RLOG("HugeRealloc " << asString(ptr) << ", size: " << asString(count));
	return b;
}

              The lower limit for this parameter is 0.  The upper limit is
              DEFAULT_MMAP_THRESHOLD_MAX: 512*1024 on 32-bit systems or
              4*1024*1024*sizeof(long) on 64-bit systems.

              Note: Nowadays, glibc uses a dynamic mmap threshold by
              default.  The initial value of the threshold is 128*1024, but
              when blocks larger than the current threshold and less than or
              equal to DEFAULT_MMAP_THRESHOLD_MAX are freed, the threshold
              is adjusted upward to the size of the freed block.  When
              dynamic mmap thresholding is in effect, the threshold for
              trimming the heap is also dynamically adjusted to be twice the
              dynamic mmap threshold.  Dynamic adjustment of the mmap
              threshold is disabled if any of the M_TRIM_THRESHOLD,
              M_TOP_PAD, M_MMAP_THRESHOLD, or M_MMAP_MAX parameters is set.