Skip to content

size_t for gc globals #1393

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
Aidan63 merged 2 commits into from
Sep 10, 2026
Merged

size_t for gc globals #1393

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
7ac1291
size_t for gc globals
Sep 9, 2026
149418a
Remove commented out log referring to now non existing global
Sep 10, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 3 additions & 3 deletions include/hx/GC.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -159,13 +159,13 @@ extern std::atomic_uint gPauseForCollect;


// Minimum total memory - used + buffer for new objects
extern int sgMinimumWorkingMemory;
extern size_t sgMinimumWorkingMemory;

// Minimum free memory - not counting used memory
extern int sgMinimumFreeSpace;
extern size_t sgMinimumFreeSpace;

// Also ensure that the free memory is larger than this amount of used memory
extern int sgTargetFreeSpacePercentage;
extern size_t sgTargetFreeSpacePercentage;


extern HXCPP_EXTERN_CLASS_ATTRIBUTES int gByteMarkID;
Expand Down
42 changes: 24 additions & 18 deletions src/hx/gc/GcCommon.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,14 +27,14 @@ extern void __hxt_new_string(void* result, int size);
namespace hx
{
#if defined(HX_MACOS) || defined(HX_WINDOWS) || defined(HX_LINUX) || defined(__ORBIS__)
int sgMinimumWorkingMemory = 20*1024*1024;
int sgMinimumFreeSpace = 10*1024*1024;
size_t sgMinimumWorkingMemory = 20*1024*1024;
size_t sgMinimumFreeSpace = 10*1024*1024;
#else
int sgMinimumWorkingMemory = 8*1024*1024;
int sgMinimumFreeSpace = 4*1024*1024;
size_t sgMinimumWorkingMemory = 8*1024*1024;
size_t sgMinimumFreeSpace = 4*1024*1024;
#endif
// Once you use more than the minimum, this kicks in...
int sgTargetFreeSpacePercentage = 100;
size_t sgTargetFreeSpacePercentage = 100;



Expand All @@ -44,30 +44,36 @@ int sgTargetFreeSpacePercentage = 100;
// Called internally before and GC operations
void CommonInitAlloc()
{
// It is probably safe to use something like strtoull for parsing the size_t values as I'm sure every reasonable implementation treats them as uint64_t.
// But just to be pedantic let's use sscanf which is the only "official" way to do this in C++11.
// C++17 gives us std::charconv but I haven't twisted enough arms yet to have 17 be the minimum version.

#if !defined(HX_WINRT) && !defined(__SNC__) && !defined(__ORBIS__)
const char *minimumWorking = getenv("HXCPP_MINIMUM_WORKING_MEMORY");
const char *minimumWorking{ getenv("HXCPP_MINIMUM_WORKING_MEMORY") };
if (minimumWorking)
{
int mem = atoi(minimumWorking);
if (mem>0)
sgMinimumWorkingMemory = mem;
if (1 != std::sscanf(minimumWorking, "%zu", &sgMinimumWorkingMemory))
{
hx::CriticalError(HX_CSTRING("Failed to parse number from HXCPP_MINIMUM_WORKING_MEMORY environment variable"));
}
}

const char *minimumFreeSpace = getenv("HXCPP_MINIMUM_FREE_SPACE");
const char* minimumFreeSpace{ getenv("HXCPP_MINIMUM_FREE_SPACE") };
if (minimumFreeSpace)
{
int mem = atoi(minimumFreeSpace);
if (mem>0)
sgMinimumFreeSpace = mem;
if (1 != std::sscanf(minimumFreeSpace, "%zu", &sgMinimumFreeSpace))
{
hx::CriticalError(HX_CSTRING("Failed to parse number from HXCPP_MINIMUM_FREE_SPACE environment variable"));
}
}


const char *targetFree = getenv("HXCPP_TARGET_FREE_SPACE");
const char* targetFree{ getenv("HXCPP_TARGET_FREE_SPACE") };
if (targetFree)
{
int percent = atoi(targetFree);
if (percent>0)
sgTargetFreeSpacePercentage = percent;
if (1 != std::sscanf(targetFree, "%zu", &sgTargetFreeSpacePercentage))
{
hx::CriticalError(HX_CSTRING("Failed to parse number from HXCPP_TARGET_FREE_SPACE environment variable"));
}
}
#endif
}
Expand Down
27 changes: 11 additions & 16 deletions src/hx/gc/Immix.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -97,7 +97,6 @@ void DebuggerTrap()

static bool sgAllocInit = 0;
static bool sgInternalEnable = true;
static void *sgObject_root = 0;

@tobil4sk tobil4sk Sep 9, 2026 •
edited
Loading

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Just to verify this removal, it seems this variable has been unused since: f7d27a4

// With virtual inheritance, stack pointers can point to the middle of an object
#ifdef _MSC_VER
// MSVC optimizes by taking the address of an initernal data member
Expand Down Expand Up @@ -5126,13 +5125,13 @@ class GlobalAllocator
else
{
size_t mem = mRowsInUse<<IMMIX_LINE_BITS;
size_t targetFree = std::max((size_t)hx::sgMinimumFreeSpace, mem/100 * (size_t)hx::sgTargetFreeSpacePercentage );
targetFree = std::min(targetFree, (size_t)sgMaximumFreeSpace );
sWorkingMemorySize = std::max( mem + targetFree, (size_t)hx::sgMinimumWorkingMemory);
size_t targetFree = std::max(hx::sgMinimumFreeSpace, mem / 100 * hx::sgTargetFreeSpacePercentage );
targetFree = std::min(targetFree, sgMaximumFreeSpace );
sWorkingMemorySize = std::max( mem + targetFree, hx::sgMinimumWorkingMemory);

size_t allMem = GetWorkingMemory();
// 8 Meg too much?
size_t allowExtra = std::max( (size_t)8*1024*1024, sWorkingMemorySize*5/4 );
size_t allowExtra = std::max(size_t{ 8 } * 1024 * 1024, sWorkingMemorySize * 5 / 4);

if ( allMem > sWorkingMemorySize + allowExtra )
{
Expand Down Expand Up @@ -5176,9 +5175,9 @@ class GlobalAllocator
if (doRelease)
{
size_t mem = mRowsInUse<<IMMIX_LINE_BITS;
size_t targetFree = std::max((size_t)hx::sgMinimumFreeSpace, bytesInUse/100 *hx::sgTargetFreeSpacePercentage );
targetFree = std::min(targetFree, (size_t)sgMaximumFreeSpace );
size_t targetMem = std::max( mem + targetFree, (size_t)hx::sgMinimumWorkingMemory) +
size_t targetFree = std::max(hx::sgMinimumFreeSpace, bytesInUse/100 *hx::sgTargetFreeSpacePercentage );
targetFree = std::min(targetFree, sgMaximumFreeSpace );
size_t targetMem = std::max( mem + targetFree, hx::sgMinimumWorkingMemory) +
(2<<(IMMIX_BLOCK_GROUP_BITS+IMMIX_BLOCK_BITS));

if (inForceCompact)
Expand Down Expand Up @@ -5225,14 +5224,14 @@ class GlobalAllocator
size_t mem = mRowsInUse<<IMMIX_LINE_BITS;
size_t baseMem = full ? bytesInUse : mem;
#ifdef HXCPP_GC_DYNAMIC_SIZE
size_t targetFree = std::max((size_t)hx::sgMinimumFreeSpace, (size_t)(baseMem * profileCollectSummary.spaceFactor ) );
size_t targetFree = std::max(hx::sgMinimumFreeSpace, baseMem * profileCollectSummary.spaceFactor );
#else
size_t targetFree = std::max((size_t)hx::sgMinimumFreeSpace, baseMem/100 *hx::sgTargetFreeSpacePercentage );
size_t targetFree = std::max(hx::sgMinimumFreeSpace, baseMem / 100 *hx::sgTargetFreeSpacePercentage );
#endif
targetFree = std::min(targetFree, (size_t)sgMaximumFreeSpace );
targetFree = std::min(targetFree, sgMaximumFreeSpace );
// Only adjust if non-generational
if (!generational)
sWorkingMemorySize = std::max( mem + targetFree, (size_t)hx::sgMinimumWorkingMemory);
sWorkingMemorySize = std::max( mem + targetFree, hx::sgMinimumWorkingMemory);

#if defined(SHOW_FRAGMENTATION) || defined(SHOW_MEM_EVENTS)
GCLOG("Target memory %s, using %s\n", formatBytes(sWorkingMemorySize).c_str(), formatBytes(mem).c_str() );
Expand Down Expand Up @@ -6556,11 +6555,7 @@ void InitAlloc()
sgFinalizers = new FinalizerList();
sFinalizerLock = new std::mutex();
sGCRootLock = new std::mutex();
hx::Object tmp;
void **stack = *(void ***)(&tmp);
sgObject_root = stack[0];

//GCLOG("__root pointer %p\n", sgObject_root);
gMainThreadContext = new LocalAllocator();

tlsStackContext = gMainThreadContext;
Expand Down
Loading