VM: new primitive (callback-room) for querying the VM about memory usage

The word works exactly like (code-room) except it looks at the memory
usage in the callback heap instead of the code heap.

diff --git a/basis/stack-checker/known-words/known-words.factor b/basis/stack-checker/known-words/known-words.factor
index 7e9ce0120642c2060eebd4ff54452aad4de0e97d..471879673fbf76a55276ff3aa823da3fca69d6c1 100644 (file)
--- a/basis/stack-checker/known-words/known-words.factor
+++ b/basis/stack-checker/known-words/known-words.factor
@@ -359,6 +359,7 @@ M: object infer-call* \ call bad-macro-input ;
 \ context-object { fixnum } { object } define-primitive \ context-object make-flushable
 \ context-object-for { fixnum c-ptr } { object } define-primitive \ context-object-for make-flushable
 \ current-callback { } { fixnum } define-primitive \ current-callback make-flushable
+\ (callback-room) { } { byte-array } define-primitive \ (callback-room) make-flushable
 \ (data-room) { } { byte-array } define-primitive \ (data-room) make-flushable
 \ datastack { } { array } define-primitive \ datastack make-flushable
 \ datastack-for { c-ptr } { array } define-primitive \ datastack-for make-flushable

diff --git a/basis/tools/memory/memory-docs.factor b/basis/tools/memory/memory-docs.factor
index 61c51dbf92d5f3c228066fb3f56270b24afc29ac..3588ac953afcb5fae5b9b871de3790c69360f343 100644 (file)
--- a/basis/tools/memory/memory-docs.factor
+++ b/basis/tools/memory/memory-docs.factor
@@ -51,8 +51,12 @@ HELP: gc-events
 
 HELP: data-room
 { $values { "data-heap-room" data-heap-room } }
-{ $description "Queries the VM for memory usage information." } ;
+{ $description "Queries the VM for memory usage in the data heap." } ;
 
 HELP: code-room
 { $values { "mark-sweep-sizes" mark-sweep-sizes } }
-{ $description "Queries the VM for memory usage information." } ;
+{ $description "Queries the VM for memory usage in the code heap." } ;
+
+HELP: callback-room
+{ $values { "mark-sweep-sizes" mark-sweep-sizes } }
+{ $description "Queries the VM for memory usage in the callback heap." } ;

diff --git a/basis/tools/memory/memory-tests.factor b/basis/tools/memory/memory-tests.factor
index 1ea5854939a9e6dd87b360d2b72b470e3e3ad6eb..52c06f4fb0d34e4c39dd0ec88294bce6d717e3c0 100644 (file)
--- a/basis/tools/memory/memory-tests.factor
+++ b/basis/tools/memory/memory-tests.factor
@@ -7,3 +7,4 @@ IN: tools.memory.tests
 [ ] [ gc-events. ] unit-test
 [ ] [ gc-stats. ] unit-test
 [ ] [ gc-summary. ] unit-test
+[ ] [ callback-room. ] unit-test

diff --git a/basis/tools/memory/memory.factor b/basis/tools/memory/memory.factor
index fd8cd7dda63cdf44cd8380d9478a901e56709051..7250c47edda90a283050e2a513cd0895b9218195 100644 (file)
--- a/basis/tools/memory/memory.factor
+++ b/basis/tools/memory/memory.factor
@@ -291,10 +291,17 @@ PRIVATE>
 : code-room ( -- mark-sweep-sizes )
     (code-room) mark-sweep-sizes memory>struct ;
 
+: callback-room ( -- mark-sweep-sizes )
+    (callback-room) mark-sweep-sizes memory>struct ;
+
 : code-room. ( -- )
     "== Code heap ==" print nl
     code-room mark-sweep-table. nl
     get-code-blocks code-block-stats code-block-table. ;
 
+: callback-room. ( -- )
+    "== Callback heap ==" print nl
+    callback-room mark-sweep-table. ;
+
 : room. ( -- )
-    data-room. nl code-room. ;
+    data-room. nl code-room. nl callback-room. ;

diff --git a/core/bootstrap/primitives.factor b/core/bootstrap/primitives.factor
index 2dfb949b21f4f4db25cf633c71c2be987fcd803d..fc5649470caadfc9a6ba8f0db54201e14fa8f6ec 100755 (executable)
--- a/core/bootstrap/primitives.factor
+++ b/core/bootstrap/primitives.factor
@@ -525,8 +525,9 @@ tuple
     { "float>fixnum" "math.private" "primitive_float_to_fixnum" ( x -- y ) }
     { "all-instances" "memory" "primitive_all_instances" ( -- array ) }
     { "(code-blocks)" "tools.memory.private" "primitive_code_blocks" ( -- array ) }
-    { "(code-room)" "tools.memory.private" "primitive_code_room" ( -- code-room ) }
+    { "(code-room)" "tools.memory.private" "primitive_code_room" ( -- allocator-room ) }
     { "compact-gc" "memory" "primitive_compact_gc" ( -- ) }
+    { "(callback-room)" "tools.memory.private" "primitive_callback_room" ( -- allocator-room ) }
     { "(data-room)" "tools.memory.private" "primitive_data_room" ( -- data-room ) }
     { "disable-gc-events" "tools.memory.private" "primitive_disable_gc_events" ( -- events ) }
     { "enable-gc-events" "tools.memory.private" "primitive_enable_gc_events" ( -- ) }

diff --git a/core/kernel/kernel.factor b/core/kernel/kernel.factor
index ddf1fa8fd23f66998aba6684d6fc099d74d8f2d0..5ef3cfe6b59132242865d83857d2b15b7c5d12eb 100644 (file)
--- a/core/kernel/kernel.factor
+++ b/core/kernel/kernel.factor
@@ -352,8 +352,6 @@ CONSTANT: OBJ-WAITING-CALLBACKS 73
 
 CONSTANT: OBJ-SIGNAL-PIPE 74
 
-CONSTANT: OBJ-INSTALL-PREFIX 75
-
 ! Context object count and identifiers must be kept in sync with:
 !   vm/contexts.hpp
 

diff --git a/extra/tools/time/struct/struct.factor b/extra/tools/time/struct/struct.factor
index 022124cc1225f872f90f775e299ef0204c9f89c4..16a0549ec57e86e08e2f0d480a870f6a0595e973 100644 (file)
--- a/extra/tools/time/struct/struct.factor
+++ b/extra/tools/time/struct/struct.factor
@@ -7,7 +7,8 @@ IN: tools.time.struct
 STRUCT: benchmark-data
     { time ulonglong }
     { data-room data-heap-room }
-    { code-room mark-sweep-sizes } ;
+    { code-room mark-sweep-sizes }
+    { callback-room mark-sweep-sizes } ;
 
 STRUCT: benchmark-data-pair
     { start benchmark-data }
@@ -16,8 +17,9 @@ STRUCT: benchmark-data-pair
 : <benchmark-data> ( -- benchmark-data )
     \ benchmark-data <struct>
         nano-count >>time
+        data-room >>data-room
         code-room >>code-room
-        data-room >>data-room ; inline
+        callback-room >>callback-room ; inline
 
 : <benchmark-data-pair> ( start stop -- benchmark-data-pair )
     \ benchmark-data-pair <struct>
@@ -28,4 +30,3 @@ STRUCT: benchmark-data-pair
     <benchmark-data>
     [ call ] dip
     <benchmark-data> <benchmark-data-pair> ; inline
-

diff --git a/vm/callbacks.cpp b/vm/callbacks.cpp
index 8aa9e80774c339dd89958be58e7b8b8350fd0ee4..45e54af0d3f35b4a8f312e020d406e401a6d98d8 100644 (file)
--- a/vm/callbacks.cpp
+++ b/vm/callbacks.cpp
@@ -65,7 +65,6 @@ void callback_heap::update(code_block* stub) {
 }
 
 code_block* callback_heap::add(cell owner, cell return_rewind) {
-  std::cout << "callback_heap::add" << std::endl;
   tagged<array> code_template(parent->special_objects[CALLBACK_STUB]);
   tagged<byte_array> insns(array_nth(code_template.untagged(), 1));
   cell size = array_capacity(insns.untagged());
@@ -137,4 +136,10 @@ void factor_vm::primitive_callback() {
   ctx->push(allot_alien(func));
 }
 
+/* Allocates memory */
+void factor_vm::primitive_callback_room() {
+  allocator_room room = callbacks->allocator->as_allocator_room();
+  ctx->push(tag<byte_array>(byte_array_from_value(&room)));
+}
+
 }

diff --git a/vm/code_heap.cpp b/vm/code_heap.cpp
index 8ec6e0a61fb156e19794cf60969e918fd3dc0bdf..db45cb59f08f9d9d60f29496169320f6d6c5e861 100644 (file)
--- a/vm/code_heap.cpp
+++ b/vm/code_heap.cpp
@@ -215,21 +215,9 @@ void factor_vm::primitive_modify_code_heap() {
     initialize_code_blocks();
 }
 
-code_heap_room factor_vm::code_room() {
-  code_heap_room room;
-
-  room.size = code->allocator->size;
-  room.occupied_space = code->allocator->occupied_space();
-  room.total_free = code->allocator->free_space();
-  room.contiguous_free = code->allocator->largest_free_block();
-  room.free_block_count = code->allocator->free_block_count();
-
-  return room;
-}
-
 /* Allocates memory */
 void factor_vm::primitive_code_room() {
-  code_heap_room room = code_room();
+  allocator_room room = code->allocator->as_allocator_room();
   ctx->push(tag<byte_array>(byte_array_from_value(&room)));
 }
 

diff --git a/vm/code_heap.hpp b/vm/code_heap.hpp
index cfd7fd3589d515107e2da61f29d97705e2cbb5cb..28b066afc731364746fefb1161739374e75f65cc 100644 (file)
--- a/vm/code_heap.hpp
+++ b/vm/code_heap.hpp
@@ -57,12 +57,4 @@ struct code_heap {
   }
 };
 
-struct code_heap_room {
-  cell size;
-  cell occupied_space;
-  cell total_free;
-  cell contiguous_free;
-  cell free_block_count;
-};
-
 }

diff --git a/vm/free_list_allocator.hpp b/vm/free_list_allocator.hpp
index f536fcd39e21dedb9c92b6ff964954bd0e9266c6..13598f49eb28826897efbda6b66fc9ca1b34f91a 100644 (file)
--- a/vm/free_list_allocator.hpp
+++ b/vm/free_list_allocator.hpp
@@ -1,5 +1,13 @@
 namespace factor {
 
+struct allocator_room {
+  cell size;
+  cell occupied_space;
+  cell total_free;
+  cell contiguous_free;
+  cell free_block_count;
+};
+
 template <typename Block> struct free_list_allocator {
   cell size;
   cell start;
@@ -28,6 +36,7 @@ template <typename Block> struct free_list_allocator {
   template <typename Iterator, typename Fixup>
   void iterate(Iterator& iter, Fixup fixup);
   template <typename Iterator> void iterate(Iterator& iter);
+  allocator_room as_allocator_room();
 };
 
 template <typename Block>
@@ -208,4 +217,16 @@ void free_list_allocator<Block>::iterate(Iterator& iter) {
   iterate(iter, no_fixup());
 }
 
+template <typename Block>
+allocator_room free_list_allocator<Block>::as_allocator_room() {
+  allocator_room room;
+
+  room.size = size;
+  room.occupied_space = occupied_space();
+  room.total_free = free_space();
+  room.contiguous_free = largest_free_block();
+  room.free_block_count = free_block_count();
+  return room;
+}
+
 }

diff --git a/vm/gc.cpp b/vm/gc.cpp
index 9bd47b0a27a14b05037bf6e525cb3005c3f3cedf..3e24f1e11ec1e6096673ee9c3cc64f6f289ac301 100644 (file)
--- a/vm/gc.cpp
+++ b/vm/gc.cpp
@@ -14,7 +14,7 @@ gc_event::gc_event(gc_op op, factor_vm* parent)
       code_sweep_time(0),
       compaction_time(0) {
   data_heap_before = parent->data_room();
-  code_heap_before = parent->code_room();
+  code_heap_before = parent->code->allocator->as_allocator_room();
   start_time = nano_count();
 }
 
@@ -53,7 +53,7 @@ void gc_event::ended_compaction() {
 
 void gc_event::ended_gc(factor_vm* parent) {
   data_heap_after = parent->data_room();
-  code_heap_after = parent->code_room();
+  code_heap_after = parent->code->allocator->as_allocator_room();
   total_time = (cell)(nano_count() - start_time);
 }
 

diff --git a/vm/gc.hpp b/vm/gc.hpp
index 8c2b7f12a508eb380881beac5495ac3cb3d5cb60..91e8c186b7a348f85fda01ea72bdcdfc0da123dc 100644 (file)
--- a/vm/gc.hpp
+++ b/vm/gc.hpp
@@ -12,9 +12,9 @@ enum gc_op {
 struct gc_event {
   gc_op op;
   data_heap_room data_heap_before;
-  code_heap_room code_heap_before;
+  allocator_room code_heap_before;
   data_heap_room data_heap_after;
-  code_heap_room code_heap_after;
+  allocator_room code_heap_after;
   cell cards_scanned;
   cell decks_scanned;
   cell code_blocks_scanned;

diff --git a/vm/primitives.hpp b/vm/primitives.hpp
index 5e386034a002d95a56cd98e69a1619ae98b4e3a1..d7cefd5d92ddbcc69b52b807b8358a261179b814 100644 (file)
--- a/vm/primitives.hpp
+++ b/vm/primitives.hpp
@@ -10,8 +10,8 @@ namespace factor {
       _(bignum_gcd) _(bignum_multiply) _(bignum_not) _(bignum_or)              \
       _(bignum_shift) _(bignum_subtract) _(bignum_to_fixnum)                   \
       _(bignum_to_fixnum_strict) _(bignum_xor)                                 \
-      _(bits_double) _(bits_float) _(byte_array) _(callback) _(callstack)      \
-      _(callstack_bounds) _(callstack_for) _(callstack_to_array)               \
+      _(bits_double) _(bits_float) _(byte_array) _(callback) _(callback_room)  \
+      _(callstack) _(callstack_bounds) _(callstack_for) _(callstack_to_array)  \
       _(check_datastack) _(clear_samples) _(clone) _(code_blocks) _(code_room) \
       _(compact_gc) _(compute_identity_hashcode) _(context_object)             \
       _(context_object_for) _(current_callback) _(data_room) _(datastack)      \

diff --git a/vm/vm.hpp b/vm/vm.hpp
index 6fc899ae0b07c9d396711af03bc1531c08f8f909..d1c49f7fb22a025d7eb245aa4fca894ffa032e46 100644 (file)
--- a/vm/vm.hpp
+++ b/vm/vm.hpp
@@ -605,7 +605,6 @@ struct factor_vm {
   void update_code_heap_words(bool reset_inline_caches);
   void initialize_code_blocks();
   void primitive_modify_code_heap();
-  code_heap_room code_room();
   void primitive_code_room();
   void primitive_strip_stack_traces();
   cell code_blocks();
@@ -614,6 +613,7 @@ struct factor_vm {
   // callbacks
   void init_callbacks(cell size);
   void primitive_callback();
+  void primitive_callback_room();
 
   // image
   void init_objects(image_header* h);