Permalink
Browse files

2012-02-08-19.40.47: src/c/h/runtime-configuration.h: For clarity ren…

…amed DEFAULT_OLDEST_AGEGROUP_KEEPING_IDLE_FROMSPACE_BUFFERS -> DEFAULT_OLDEST_AGEGROUP_RETAINING_FROMSPACE_SIBS_BETWEEN_HEAPCLEANINGS and added a long comment block.
  • Loading branch information...
1 parent da8787c commit 787cf072b10e472eb82cb6265a575fa1bf974202 Cynbe committed Feb 9, 2012
View
1 change-history
@@ -1,3 +1,4 @@
+2012-02-08-17.58.52: src/c/main/timers.c: For clarity and consistency renamed start_cleaning_timer -> start_heapcleaning_timer, stop_cleaning_timer -> stop_heapcleaning_timer.
2012-02-08-17.46.29: src/c/heapcleaner/heapclean-n-agegroups.c: More commenting.
2012-02-08-05.14.38: src/c/heapcleaner/heapclean-n-agegroups.c: More commenting -- set_up_empty_tospace_buffers() appears to fully decrypted at this point.
2012-02-08-04.24.06: src/c/h/runtime-base.h: Eliminated SUCCESS and FAILURE, which were just nonstandard synonyms for TRUE and FALSE.
View
37 src/A.GARBAGE-COLLECTOR.OVERVIEW
@@ -158,7 +158,7 @@ heapcleaner and associated code and datastructures:
from one agegroup to the next after it has survived
two heapcleanings in its current agegroup.
To implement this we have in each sib a pointer
- fromspace.oldstuff_end // See struct sib in src/c/h/heap.h
+ fromspace.oldstuff_end // See struct sib in src/c/h/heap.h
which tracks the boundary between the "old"
(survived one heapcleaning) and "young" chunks
within that sib.
@@ -179,7 +179,7 @@ heapcleaner and associated code and datastructures:
o When heapcleaning a given agegroup, we require
that the next agegroup have enough space to
- guarantee that there will be no overflow problems. // See set_up_empty_tospace_buffers() in src/c/heapcleaner/heapclean-n-agegroups.c
+ guarantee that there will be no overflow problems. // See set_up_empty_tospace_buffers() in src/c/heapcleaner/heapclean-n-agegroups.c
In particular, agegroup0 is about 256KB,
almost all of which may wind up in any of the four
agegroup1 sibs, so we require that each agegroup1
@@ -188,10 +188,35 @@ heapcleaner and associated code and datastructures:
(This is almost always vast overkill in practice,
because agegroup0 is usually almost all garbage, but
it is much better to be safe than sorry here!)
- More generally, when cleaning a given sib S,
- we require that the older sib S' (to which chunks may
- get promoted) have at least as much space as as that
- occupied by all "old" chunks in S.
+
+ More generally, when cleaning a given sib, we require that
+ the to-space buffer for it have enough space to hold:
+
+ 1) All "young" chunks in the from-space buffer for that
+ sib. (A chunk is "young" in a sib if it has not yet
+ survived a heapcleaning in that sib.) These will
+ potentially all get copied into to-space for the
+ sib, so there must be room enough to hold them all.
+
+ 2) All "old" chunks in the from-space buffer for the
+ corresponding next-younger sib. These will all
+ potentially get promoted to our sib, so we must
+ have sufficient room to hold all of them.
+
+ 3) User code may be creating new chunk(s) in this sib. // See src/c/heapcleaner/make-strings-and-vectors-etc.c
+ The to-space buffer must contain enough additional
+ space to allow this.
+
+ o To-space buffers are unused between heapcleanings.
+ With small ones it is most efficient to simply retain
+ them between heapcleanings.
+ With large ones it is most efficient to return them to
+ the host OS and re-allocate them when next used. // See free_agegroup() in src/c/heapcleaner/heapcleaner-stuff.c
+ The policy on what "large" means in this context is set by
+ DEFAULT_OLDEST_AGEGROUP_RETAINING_FROMSPACE_SIBS_BETWEEN_HEAPCLEANINGS
+ in src/c/h/runtime-configuration.h
+ (See additional comments there.) Currently "large" means
+ 1GB or above, roughly.
View
7 src/A.HEAP.OVERVIEW
@@ -410,7 +410,7 @@ Nomenclature:
// (i.e., store into) one of these can potentially introduce
// a pointer from one agegroup into a younger agegroup. During
// partial heapcleanings it is essential that we know of every
-// such cross-agegroup pointer.
+// such anachronistic pointer.
// Doing this requires special machinery:
//
// o Every time the compiler generates code which
@@ -455,11 +455,6 @@ Nomenclature:
//
// src/c/h/heap.h
//
-// "bibop" stands for "big bag of pages". It is a technique for avoiding
-// explicit tags on small ram records by packing them in pages which all
-// contain the same type of record and then setting up just one typetag
-// per memory page instead of one per record.
-//
// We map 64K "books" to sibids via book_to_sibid__global.
// On 32-bit machines a single 64K-entry table suffices to
// cover the entire 32-bit address space.
View
41 src/c/h/heap.h
@@ -43,7 +43,7 @@ struct cleaner_args { // "typedef struct cleaner_args_rec Heapcleaner_Args;
//
Punt agegroup0_buffer_bytesize;
int active_agegroups;
- int oldest_agegroup_keeping_idle_fromspace_buffers; // We keep (instead of freeing) idle fromspaces for this and all younger agegroups.
+ int oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings; // We keep (instead of freeing) idle fromspaces for this and all younger agegroups.
};
// Forward declarations to enable mutual recursion:
@@ -54,39 +54,40 @@ typedef struct hugechunk_region Hugechunk_Region;
typedef struct hugechunk Hugechunk;
typedef struct agegroup Agegroup;
-/* typedef struct heap Heap; */ // From src/c/h/runtime-base.h
+/* typedef struct heap Heap; */ // From src/c/h/runtime-base.h
- // Quire def in src/c/h/get-quire-from-os.h
- // struct quire def in src/c/ram/get-quire-from-mmap.c
- // struct quire def in src/c/ram/get-quire-from-mach.c
- // struct quire def in src/c/ram/get-quire-from-win32.c
+ // Quire def in src/c/h/get-quire-from-os.h
+ // struct quire def in src/c/ram/get-quire-from-mmap.c
+ // struct quire def in src/c/ram/get-quire-from-mach.c
+ // struct quire def in src/c/ram/get-quire-from-win32.c
// A heap consists of one agegroup0 buffer per pthread
// plus one or more older agegroups, which are shared
// between all pthreads.
//
struct heap {
- Val* agegroup0_master_buffer; // Base address of the master buffer from which we allocate the individual per-task agegroup0 buffers.
- Punt agegroup0_master_buffer_bytesize; // Size-in-bytes of the agegroup0_buffers master buffer.
- Quire* quire; // The memory region we got from the host OS to contain the book_to_sibid map and agegroup0 buffer(s).
+ Val* agegroup0_master_buffer; // Base address of the master buffer from which we allocate the individual per-task agegroup0 buffers.
+ Punt agegroup0_master_buffer_bytesize; // Size-in-bytes of the agegroup0_buffers master buffer.
+ Quire* quire; // The memory region we got from the host OS to contain the book_to_sibid map and agegroup0 buffer(s).
- int active_agegroups; // Number of active agegroups.
- int oldest_agegroup_keeping_idle_fromspace_buffers; // Save the from-space for agegroups 1..oldest_agegroup_keeping_idle_fromspace_buffers.
- int agegroup0_heapcleanings_count; // Count how many times we've cleaned (garbage-collected) heap agegroup zero.
+ int active_agegroups; // Number of active agegroups.
+ int agegroup0_heapcleanings_count; // Count how many times we've cleaned (garbage-collected) heap agegroup zero.
+ int oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings; // Between heapcleanings retain the from-space buffer (only) for agegroups 1..oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings.
+ // For more background, see comments on DEFAULT_OLDEST_AGEGROUP_RETAINING_FROMSPACE_SIBS_BETWEEN_HEAPCLEANINGS in src/c/h/runtime-configuration.h
- Agegroup* agegroup[ MAX_AGEGROUPS ]; // Age-group #i is in agegroup[i-1]
- int hugechunk_ramregion_count; // Number of active hugechunk regions.
- Hugechunk_Region* hugechunk_ramregions; // List of hugechunk regions.
- Hugechunk* hugechunk_freelist; // Freelist header for hugechunks.
-
- Val* weak_pointers_forwarded_during_heapcleaning; // List of weak pointers forwarded during heapcleaning.
+ Agegroup* agegroup[ MAX_AGEGROUPS ]; // Age-group #i is in agegroup[i-1]
+ int hugechunk_ramregion_count; // Number of active hugechunk regions.
+ Hugechunk_Region* hugechunk_ramregions; // List of hugechunk regions.
+ Hugechunk* hugechunk_freelist; // Freelist header for hugechunks.
+ Val* weak_pointers_forwarded_during_heapcleaning; // List of weak pointers forwarded during heapcleaning.
+ // This is really local state for the heapcleaner -- it doesn't belong here. XXX SUCKO FIXME.
//
- Bigcounter total_bytes_allocated; // Cleaner statistics -- tracks number of bytes allocated.
- Bigcounter total_bytes_copied_to_sib[ MAX_AGEGROUPS ][ MAX_PLAIN_SIBS ]; // Cleaner statistics -- tracks number of bytes copied into each sib buffer.
+ Bigcounter total_bytes_allocated; // Cleaner statistics -- tracks number of bytes allocated.
+ Bigcounter total_bytes_copied_to_sib[ MAX_AGEGROUPS ][ MAX_PLAIN_SIBS ]; // Cleaner statistics -- tracks number of bytes copied into each sib buffer.
};
View
39 src/c/h/runtime-configuration.h
@@ -19,7 +19,44 @@
#define MAX_ACTIVE_AGEGROUPS 14 // Should agree with MAX_AGEGROUPS in sibid.h.
-#define DEFAULT_OLDEST_AGEGROUP_KEEPING_IDLE_FROMSPACE_BUFFERS 2 // Keep idle fromspace regions for ages 1 & 2
+#define DEFAULT_OLDEST_AGEGROUP_RETAINING_FROMSPACE_SIBS_BETWEEN_HEAPCLEANINGS 2 // Keep idle fromspace quires for ages 1 & 2
+ //
+ // By design each successive agegroup contains buffers ten
+ // times larger, heapcleaned ("garbage collected") one-tenth
+ // as often:
+ //
+ // The agegroup0 buffer is about 1MB and heapcleaned about 100 times/sec;
+ // The agegroup1 buffers run about 10MB and heapcleaned about 10 times/sec;
+ // The agegroup2 buffers run about 100MB and heapcleaned about 1 times/sec;
+ //
+ // During heapcleaning each agegroup requires twice as much ram:
+ // A from-space to copy from, and a to-space to copy into.
+ // Between heapcleanings, these extra copies are just waste space.
+ // The policy question here is: Is it better to retain these unused
+ // buffers between heapcleanings, or to return them to the OS?
+ // The considerations are:
+ //
+ // o Allocating and returning them are system calls, hence by
+ // rule of thumb take a millisecond or so each.
+ //
+ // o In the modern virtual memory environment, "ram" which goes
+ // unused long enough will page out to disk. Paging it out
+ // to disk takes time -- tens of milliseconds or more -- and
+ // paging it back in when next needed will take just as much
+ // time. Paging a 100MB buffer out might take seconds. So
+ // So for a large buffer, returning it to the OS and then
+ // allocating it again when next needed can be MUCH faster
+ // than letting it page to and from disk.
+ //
+ // Clearly, for very small buffers it is better to just retain them.
+ // Equally, for very large buffers it is better to return and re-allocate them.
+ // So the question is just at what buffer size we should change policies.
+ // The DEFAULT_OLDEST_AGEGROUP_RETAINING_FROMSPACE_SIBS_BETWEEN_HEAPCLEANINGS value here
+ // controls this policy; setting it to '2' will result in buffers of 100MB
+ // and below being retained and buffers of 1GB and above being returned
+ // and re-allocated.
+ //
+ // This gets used
#define DEFAULT_AGEGROUP0_BUFFER_BYTESIZE (256 * ONE_K_BINARY) // Size-in-bytes for the per-core (well, per-pthread)
// generation-zero heap buffer. The 256KB value is
View
4 src/c/heapcleaner/export-heap.c
@@ -160,9 +160,9 @@ static Status write_heap_image_to_file (
hh.hugechunk_sibs_count = MAX_HUGE_SIBS; // MAX_HUGE_SIBS def in src/c/h/sibid.h
hh.hugechunk_ramregion_count = heap->hugechunk_ramregion_count;
//
- hh.oldest_agegroup_keeping_idle_fromspace_buffers
+ hh.oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings
=
- heap->oldest_agegroup_keeping_idle_fromspace_buffers;
+ heap->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings;
hh.agegroup0_buffer_bytesize
=
View
2 src/c/heapcleaner/heap-debug-stuff.c
@@ -150,7 +150,7 @@ static void dump_task__guts (FILE* fd, Task* task, char* caller) {
fprintf(fd," active_agegroups d=%d\n", task->heap->active_agegroups);
fprintf(fd," hugechunk_ramregion_count d=%d\n", task->heap->hugechunk_ramregion_count);
fprintf(fd," total_bytes_allocated x=(%x,%x) (millions, 1s)\n", (unsigned int)task->heap->total_bytes_allocated.millions, (unsigned int)task->heap->total_bytes_allocated.ones );
- fprintf(fd,"oldest_agegroup_keeping_idle_fromspace_buffers d=%d\n", task->heap->oldest_agegroup_keeping_idle_fromspace_buffers);
+ fprintf(fd,"oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings d=%d\n", task->heap->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings);
for (int i = 0;
i < task->heap->active_agegroups;
View
24 src/c/heapcleaner/heapcleaner-initialization.c
@@ -87,7 +87,7 @@ Heapcleaner_Args* handle_heapcleaner_commandline_arguments (char **argv) {
//
params->agegroup0_buffer_bytesize = 0;
params->active_agegroups = -1;
- params->oldest_agegroup_keeping_idle_fromspace_buffers = -1;
+ params->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings = -1;
#define MATCH(opt) (strcmp(opt, option) == 0)
#define CHECK(opt) { \
@@ -128,11 +128,15 @@ Heapcleaner_Args* handle_heapcleaner_commandline_arguments (char **argv) {
} else if (MATCH("vmcache")) {
CHECK("vmcache");
- params->oldest_agegroup_keeping_idle_fromspace_buffers = atoi(option_arg);
- if (params->oldest_agegroup_keeping_idle_fromspace_buffers < 0) {
- params->oldest_agegroup_keeping_idle_fromspace_buffers = 0;
- } else if (params->oldest_agegroup_keeping_idle_fromspace_buffers > MAX_ACTIVE_AGEGROUPS) {
- params->oldest_agegroup_keeping_idle_fromspace_buffers = MAX_ACTIVE_AGEGROUPS;
+ params->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings = atoi(option_arg);
+
+ // Impose minimal sanity on user-specified value:
+ //
+ if (params->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings < 0) {
+ params->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings = 0;
+ } else if (
+ params->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings > MAX_ACTIVE_AGEGROUPS) {
+ params->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings = MAX_ACTIVE_AGEGROUPS;
}
} else if (MATCH("unlimited-heap")) {
@@ -189,8 +193,8 @@ void set_up_heap ( // Create and initialize the heap.
if (params->agegroup0_buffer_bytesize == 0) params->agegroup0_buffer_bytesize = DEFAULT_AGEGROUP0_BUFFER_BYTESIZE; // From src/c/h/runtime-configuration.h
if (params->active_agegroups < 0) params->active_agegroups = DEFAULT_ACTIVE_AGEGROUPS; // From src/c/h/runtime-configuration.h
- if (params->oldest_agegroup_keeping_idle_fromspace_buffers < 0) {
- params->oldest_agegroup_keeping_idle_fromspace_buffers = DEFAULT_OLDEST_AGEGROUP_KEEPING_IDLE_FROMSPACE_BUFFERS; // From src/c/h/runtime-configuration.h
+ if (params->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings < 0) {
+ params->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings = DEFAULT_OLDEST_AGEGROUP_RETAINING_FROMSPACE_SIBS_BETWEEN_HEAPCLEANINGS; // From src/c/h/runtime-configuration.h
}
// First we initialize the underlying memory system:
@@ -303,9 +307,9 @@ void set_up_heap ( // Create and initialize the heap.
}
}
- heap->oldest_agegroup_keeping_idle_fromspace_buffers
+ heap->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings
=
- params->oldest_agegroup_keeping_idle_fromspace_buffers;
+ params->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings;
heap->active_agegroups = params->active_agegroups;
//
View
4 src/c/heapcleaner/heapcleaner-stuff.c
@@ -119,7 +119,7 @@ Status set_up_tospace_sib_buffers_for_agegroup (Agegroup* ag) {
//
void free_agegroup (Heap* heap, int g) {
- // ====================
+ // =============
//
Agegroup* ag = heap->agegroup[ g ];
@@ -134,7 +134,7 @@ void free_agegroup (Heap* heap, int g) {
#endif
- if (g >= heap->oldest_agegroup_keeping_idle_fromspace_buffers) {
+ if (g >= heap->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings) {
//
return_quire_to_os( ag->fromspace_quire );
//
View
4 src/c/heapcleaner/import-heap.c
@@ -141,8 +141,8 @@ Task* import_heap_image (const char* fname, Heapcleaner_Args* params) {
if (params->active_agegroups < heap_header.active_agegroups) {
params->active_agegroups = heap_header.active_agegroups;
}
- if (params->oldest_agegroup_keeping_idle_fromspace_buffers < 0) {
- params->oldest_agegroup_keeping_idle_fromspace_buffers = heap_header.oldest_agegroup_keeping_idle_fromspace_buffers;
+ if (params->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings < 0) {
+ params->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings = heap_header.oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings;
}
task = make_task( /*is_boot:*/FALSE, params ); // make_task def in src/c/main/runtime-state.c
View
34 src/c/heapcleaner/runtime-heap-image.h
@@ -59,36 +59,36 @@ typedef struct { // The magic number and other version info.
//
typedef struct {
//
- int pthread_count; // The number of Pthreads.
- int active_agegroups; // The number of heap generations.
- int smallchunk_sibs_count; // The number of small-chunk sibs (one each for pairs, records, strings, vectors).
- int hugechunk_sibs_count; // The number of hugechunk kinds (currently 1 -- codechunks).
- int hugechunk_ramregion_count; // The number of hugechunk regions in the exporting address space.
- int oldest_agegroup_keeping_idle_fromspace_buffers; // The oldest agegroup retaining fromspace buffer, instead of freeing it after cleaning.
+ int pthread_count; // The number of Pthreads.
+ int active_agegroups; // The number of heap generations.
+ int smallchunk_sibs_count; // The number of small-chunk sibs (one each for pairs, records, strings, vectors).
+ int hugechunk_sibs_count; // The number of hugechunk kinds (currently 1 -- codechunks).
+ int hugechunk_ramregion_count; // The number of hugechunk regions in the exporting address space.
+ int oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings; // The oldest agegroup retaining fromspace buffer, instead of returning it to host OS after heapcleaning is complete.
//
- Punt agegroup0_buffer_bytesize; // The size of the agegroup0 allocation buffers used by the runtime.
+ Punt agegroup0_buffer_bytesize; // The size of the agegroup0 allocation buffers used by the runtime.
//
- Val pervasive_package_pickle_list; // Contents of PERVASIVE_PACKAGE_PICKLE_LIST_REFCELL__GLOBAL.
- Val runtime_pseudopackage; // The run-time system compilation unit root.
- Val math_package; // The asmcoded Math package root (if defined).
+ Val pervasive_package_pickle_list; // Contents of PERVASIVE_PACKAGE_PICKLE_LIST_REFCELL__GLOBAL.
+ Val runtime_pseudopackage; // The run-time system compilation unit root.
+ Val math_package; // The asmcoded Math package root (if defined).
//
} Heap_Header;
// Header for a pickled-datastructure image:
//
typedef struct {
- Unt1 smallchunk_sibs_count; // The number of small-chunk sib buffers (one each for pairs, records, strings and vectors).
- Unt1 hugechunk_sibs_count; // The number of hugechunk kinds. (Currently just 1, for codechunks.)
- Unt1 hugechunk_ramregion_count; // The number of hugechunk quires in the exporting address space.
- Bool contains_code; // TRUE iff the pickle contains code.
- Val root_chunk; // The pickle's root chunk.
+ Unt1 smallchunk_sibs_count; // The number of small-chunk sib buffers (one each for pairs, records, strings and vectors).
+ Unt1 hugechunk_sibs_count; // The number of hugechunk kinds. (Currently just 1, for codechunks.)
+ Unt1 hugechunk_ramregion_count; // The number of hugechunk quires in the exporting address space.
+ Bool contains_code; // TRUE iff the pickle contains code.
+ Val root_chunk; // The pickle's root chunk.
} Pickle_Header;
// Header for the extern table:
//
typedef struct {
- int externs_count; // The number of external symbols.
- int externs_bytesize; // The size (in bytes) of the string table area.
+ int externs_count; // The number of external symbols.
+ int externs_bytesize; // The size (in bytes) of the string table area.
} Externs_Header;
View
8 src/c/lib/heap/libmythryl-heap.c
@@ -972,19 +972,19 @@ static void set_max_retained_idle_fromspace_agegroup (Task* task, Val arg) {
if (age < 0) age = 0;
else if (age > MAX_AGEGROUPS) age = MAX_AGEGROUPS;
- if (age < heap->oldest_agegroup_keeping_idle_fromspace_buffers) {
+ if (age < heap->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings) {
//
// Free any retained memory regions:
//
- for (int i = age; i < heap->oldest_agegroup_keeping_idle_fromspace_buffers; i++) {
+ for (int i = age; i < heap->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings; i++) {
//
return_quire_to_os( heap->agegroup[i]->retained_fromspace_quire );
}
}
- ASSIGN( arg, TAGGED_INT_FROM_C_INT(heap->oldest_agegroup_keeping_idle_fromspace_buffers) );
+ ASSIGN( arg, TAGGED_INT_FROM_C_INT(heap->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings) );
- heap->oldest_agegroup_keeping_idle_fromspace_buffers
+ heap->oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings
=
age;
}
View
4 src/c/main/load-and-run-heap-image.c
@@ -23,9 +23,9 @@ void load_and_run_heap_image (
//
// agegroup0_buffer_bytesize
// active_agegroups
- // oldest_agegroup_keeping_idle_fromspace_buffers
+ // oldest_agegroup_retaining_fromspace_sibs_between_heapcleanings
//
- // possible command-line overrides of the heap parameters
+ // are possible command-line overrides of the heap parameters
// specified in the image being imported.
//
// (Non-negative values signify override.)
View
5 src/c/ram/get-quire-from-os-stuff.c
@@ -52,9 +52,8 @@ static void InitMemory () {
PageShift = j;
}
-
Quire* obtain_quire_from_os (Val_Sized_Unt bytesize) {
- // ====================
+ // ====================
//
// Get a new memory chunk from the OS.
// Return a pointer to the chunk descriptor,
@@ -101,7 +100,7 @@ Quire* obtain_quire_from_os (Val_Sized_Unt bytesize) {
void return_quire_to_os (Quire* chunk) {
- // ============================
+ // ==================
//
if (!chunk) return;

0 comments on commit 787cf07

Please sign in to comment.