bpo-37537: Compute allocated blocks in _Py_GetAllocatedBlocks() (#14680)

nascheme · web-flow · commit 5d25f2b70351 · 2019-07-10T12:04:16.000-07:00
Keeping an account of allocated blocks slows down _PyObject_Malloc()
and _PyObject_Free() by a measureable amount.  Have
_Py_GetAllocatedBlocks() iterate over the arenas to sum up the
allocated blocks for pymalloc.
diff --git a/Misc/NEWS.d/next/Core and Builtins/2019-07-10-09-56-47.bpo-37537.OkB0wd.rst b/Misc/NEWS.d/next/Core and Builtins/2019-07-10-09-56-47.bpo-37537.OkB0wd.rst
@@ -0,0 +1,3 @@
+Compute allocated pymalloc blocks inside _Py_GetAllocatedBlocks().  This
+slows down _Py_GetAllocatedBlocks() but gives a small speedup to
+_PyObject_Malloc() and _PyObject_Free().
diff --git a/Objects/obmalloc.c b/Objects/obmalloc.c
@@ -1206,12 +1206,29 @@ static size_t ntimes_arena_allocated = 0;
 /* High water mark (max value ever seen) for narenas_currently_allocated. */
 static size_t narenas_highwater = 0;
 
-static Py_ssize_t _Py_AllocatedBlocks = 0;
+static Py_ssize_t raw_allocated_blocks;
 
 Py_ssize_t
 _Py_GetAllocatedBlocks(void)
 {
-    return _Py_AllocatedBlocks;
+    Py_ssize_t n = raw_allocated_blocks;
+    /* add up allocated blocks for used pools */
+    for (uint i = 0; i < maxarenas; ++i) {
+        /* Skip arenas which are not allocated. */
+        if (arenas[i].address == NULL) {
+            continue;
+        }
+
+        uintptr_t base = (uintptr_t)_Py_ALIGN_UP(arenas[i].address, POOL_SIZE);
+
+        /* visit every pool in the arena */
+        assert(base <= (uintptr_t) arenas[i].pool_address);
+        for (; base < (uintptr_t) arenas[i].pool_address; base += POOL_SIZE) {
+            poolp p = (poolp)base;
+            n += p->ref.count;
+        }
+    }
+    return n;
 }
 
 
@@ -1622,13 +1639,12 @@ _PyObject_Malloc(void *ctx, size_t nbytes)
 {
     void* ptr;
     if (pymalloc_alloc(ctx, &ptr, nbytes)) {
-        _Py_AllocatedBlocks++;
         return ptr;
     }
 
     ptr = PyMem_RawMalloc(nbytes);
     if (ptr != NULL) {
-        _Py_AllocatedBlocks++;
+        raw_allocated_blocks++;
     }
     return ptr;
 }
@@ -1644,13 +1660,12 @@ _PyObject_Calloc(void *ctx, size_t nelem, size_t elsize)
 
     if (pymalloc_alloc(ctx, &ptr, nbytes)) {
         memset(ptr, 0, nbytes);
-        _Py_AllocatedBlocks++;
         return ptr;
     }
 
     ptr = PyMem_RawCalloc(nelem, elsize);
     if (ptr != NULL) {
-        _Py_AllocatedBlocks++;
+        raw_allocated_blocks++;
     }
     return ptr;
 }
@@ -1899,10 +1914,10 @@ _PyObject_Free(void *ctx, void *p)
         return;
     }
 
-    _Py_AllocatedBlocks--;
     if (!pymalloc_free(ctx, p)) {
         /* pymalloc didn't allocate this address */
         PyMem_RawFree(p);
+        raw_allocated_blocks--;
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+Compute allocated pymalloc blocks inside _Py_GetAllocatedBlocks(). This`
	`2`	`+slows down _Py_GetAllocatedBlocks() but gives a small speedup to`
	`3`	`+_PyObject_Malloc() and _PyObject_Free().`
Original file line number	Diff line number	Diff line change
`@@ -1206,12 +1206,29 @@ static size_t ntimes_arena_allocated = 0;`
`1206`	`1206`	`/* High water mark (max value ever seen) for narenas_currently_allocated. */`
`1207`	`1207`	`static size_t narenas_highwater = 0;`
`1208`	`1208`
`1209`		`-static Py_ssize_t _Py_AllocatedBlocks = 0;`
	`1209`	`+static Py_ssize_t raw_allocated_blocks;`
`1210`	`1210`
`1211`	`1211`	`Py_ssize_t`
`1212`	`1212`	`_Py_GetAllocatedBlocks(void)`
`1213`	`1213`	`{`
`1214`		`- return _Py_AllocatedBlocks;`
	`1214`	`+ Py_ssize_t n = raw_allocated_blocks;`
	`1215`	`+ /* add up allocated blocks for used pools */`
	`1216`	`+ for (uint i = 0; i < maxarenas; ++i) {`
	`1217`	`+ /* Skip arenas which are not allocated. */`
	`1218`	`+ if (arenas[i].address == NULL) {`
	`1219`	`+ continue;`
	`1220`	`+ }`
	`1221`	`+`
	`1222`	`+ uintptr_t base = (uintptr_t)_Py_ALIGN_UP(arenas[i].address, POOL_SIZE);`
	`1223`	`+`
	`1224`	`+ /* visit every pool in the arena */`
	`1225`	`+ assert(base <= (uintptr_t) arenas[i].pool_address);`
	`1226`	`+ for (; base < (uintptr_t) arenas[i].pool_address; base += POOL_SIZE) {`
	`1227`	`+ poolp p = (poolp)base;`
	`1228`	`+ n += p->ref.count;`
	`1229`	`+ }`
	`1230`	`+ }`
	`1231`	`+ return n;`
`1215`	`1232`	`}`
`1216`	`1233`
`1217`	`1234`
`@@ -1622,13 +1639,12 @@ _PyObject_Malloc(void *ctx, size_t nbytes)`
`1622`	`1639`	`{`
`1623`	`1640`	`void* ptr;`
`1624`	`1641`	`if (pymalloc_alloc(ctx, &ptr, nbytes)) {`
`1625`		`- _Py_AllocatedBlocks++;`
`1626`	`1642`	`return ptr;`
`1627`	`1643`	`}`
`1628`	`1644`
`1629`	`1645`	`ptr = PyMem_RawMalloc(nbytes);`
`1630`	`1646`	`if (ptr != NULL) {`
`1631`		`- _Py_AllocatedBlocks++;`
	`1647`	`+ raw_allocated_blocks++;`
`1632`	`1648`	`}`
`1633`	`1649`	`return ptr;`
`1634`	`1650`	`}`
`@@ -1644,13 +1660,12 @@ _PyObject_Calloc(void *ctx, size_t nelem, size_t elsize)`
`1644`	`1660`
`1645`	`1661`	`if (pymalloc_alloc(ctx, &ptr, nbytes)) {`
`1646`	`1662`	`memset(ptr, 0, nbytes);`
`1647`		`- _Py_AllocatedBlocks++;`
`1648`	`1663`	`return ptr;`
`1649`	`1664`	`}`
`1650`	`1665`
`1651`	`1666`	`ptr = PyMem_RawCalloc(nelem, elsize);`
`1652`	`1667`	`if (ptr != NULL) {`
`1653`		`- _Py_AllocatedBlocks++;`
	`1668`	`+ raw_allocated_blocks++;`
`1654`	`1669`	`}`
`1655`	`1670`	`return ptr;`
`1656`	`1671`	`}`
`@@ -1899,10 +1914,10 @@ _PyObject_Free(void ctx, void p)`
`1899`	`1914`	`return;`
`1900`	`1915`	`}`
`1901`	`1916`
`1902`		`- _Py_AllocatedBlocks--;`
`1903`	`1917`	`if (!pymalloc_free(ctx, p)) {`
`1904`	`1918`	`/* pymalloc didn't allocate this address */`
`1905`	`1919`	`PyMem_RawFree(p);`
	`1920`	`+ raw_allocated_blocks--;`
`1906`	`1921`	`}`
`1907`	`1922`	`}`
`1908`	`1923`