io.streams.256color: faster by caching styles

[factor.git] / vm / data_heap.cpp

diff --git a/vm/data_heap.cpp b/vm/data_heap.cpp
index f86fec9344c64a3942618bee248fc2c69c8f9534..50bd709a476561f92e93905d89c909368ac2da89 100644 (file)
--- a/vm/data_heap.cpp
+++ b/vm/data_heap.cpp
@@ -2,12 +2,7 @@
 
 namespace factor {
 
-void factor_vm::init_card_decks() {
-  cards_offset = (cell)data->cards - addr_to_card(data->start);
-  decks_offset = (cell)data->decks - addr_to_deck(data->start);
-}
-
-data_heap::data_heap(nursery_space* vm_nursery,
+data_heap::data_heap(bump_allocator* vm_nursery,
                      cell young_size_,
                      cell aging_size_,
                      cell tenured_size_) {
@@ -23,12 +18,12 @@ data_heap::data_heap(nursery_space* vm_nursery,
   cell total_size = young_size + 2 * aging_size + tenured_size + deck_size;
   seg = new segment(total_size, false);
 
-  cell cards_size = addr_to_card(total_size);
+  cell cards_size = total_size / card_size;
   cards = new card[cards_size];
   cards_end = cards + cards_size;
   memset(cards, 0, cards_size);
 
-  cell decks_size = addr_to_deck(total_size);
+  cell decks_size = total_size / deck_size;
   decks = new card_deck[decks_size];
   decks_end = decks + decks_size;
   memset(decks, 0, decks_size);
@@ -59,9 +54,9 @@ data_heap::~data_heap() {
   delete[] decks;
 }
 
-data_heap* data_heap::grow(nursery_space* vm_nursery, cell requested_bytes) {
+data_heap* data_heap::grow(bump_allocator* vm_nursery, cell requested_bytes) {
   FACTOR_ASSERT(vm_nursery->occupied_space() == 0);
-  cell new_tenured_size = (tenured_size * 2) + requested_bytes;
+  cell new_tenured_size = 2 * tenured_size + requested_bytes;
   return new data_heap(vm_nursery, young_size, aging_size, new_tenured_size);
 }
 
@@ -77,43 +72,39 @@ template <typename Generation> void data_heap::clear_decks(Generation* gen) {
   memset(&decks[first_deck], 0, last_deck - first_deck);
 }
 
-void data_heap::reset_generation(nursery_space* gen) {
-  gen->flush();
+void data_heap::reset_nursery() {
+  nursery->flush();
 }
 
-void data_heap::reset_generation(aging_space* gen) {
-  gen->flush();
-  clear_cards(gen);
-  clear_decks(gen);
-  gen->starts.clear_object_start_offsets();
+void data_heap::reset_aging() {
+  aging->flush();
+  clear_cards(aging);
+  clear_decks(aging);
+  aging->starts.clear_object_start_offsets();
 }
 
-void data_heap::reset_generation(tenured_space* gen) {
-  clear_cards(gen);
-  clear_decks(gen);
+void data_heap::reset_tenured() {
+  clear_cards(tenured);
+  clear_decks(tenured);
 }
 
 bool data_heap::high_fragmentation_p() {
-  return (tenured->largest_free_block() <= high_water_mark());
+  return tenured->largest_free_block() <= high_water_mark();
 }
 
 bool data_heap::low_memory_p() {
-  return (tenured->free_space() <= high_water_mark());
+  return tenured->free_space <= high_water_mark();
 }
 
 void data_heap::mark_all_cards() {
-  memset(cards, -1, cards_end - cards);
-  memset(decks, -1, decks_end - decks);
+  memset(cards, 0xff, cards_end - cards);
+  memset(decks, 0xff, decks_end - decks);
 }
 
 void factor_vm::set_data_heap(data_heap* data_) {
   data = data_;
-  init_card_decks();
-}
-
-void factor_vm::init_data_heap(cell young_size, cell aging_size,
-                               cell tenured_size) {
-  set_data_heap(new data_heap(&nursery, young_size, aging_size, tenured_size));
+  cards_offset = (cell)data->cards - addr_to_card(data->start);
+  decks_offset = (cell)data->decks - addr_to_deck(data->start);
 }
 
 data_heap_room factor_vm::data_room() {
@@ -127,9 +118,9 @@ data_heap_room factor_vm::data_room() {
   room.aging_free = data->aging->free_space();
   room.tenured_size = data->tenured->size;
   room.tenured_occupied = data->tenured->occupied_space();
-  room.tenured_total_free = data->tenured->free_space();
+  room.tenured_total_free = data->tenured->free_space;
   room.tenured_contiguous_free = data->tenured->largest_free_block();
-  room.tenured_free_block_count = data->tenured->free_block_count();
+  room.tenured_free_block_count = data->tenured->free_block_count;
   room.cards = data->cards_end - data->cards;
   room.decks = data->decks_end - data->decks;
   room.mark_stack = mark_stack.capacity() * sizeof(cell);
@@ -137,33 +128,26 @@ data_heap_room factor_vm::data_room() {
   return room;
 }
 
-/* Allocates memory */
+// Allocates memory
 void factor_vm::primitive_data_room() {
   data_heap_room room = data_room();
   ctx->push(tag<byte_array>(byte_array_from_value(&room)));
 }
 
-struct object_accumulator {
-  cell type;
-  std::vector<cell> objects;
-
-  explicit object_accumulator(cell type) : type(type) {}
+// Allocates memory
+cell factor_vm::instances(cell type) {
+  primitive_full_gc();
 
-  void operator()(object* obj) {
+  std::vector<cell> objects;
+  auto object_accumulator = [&](object* obj) {
     if (type == TYPE_COUNT || obj->type() == type)
       objects.push_back(tag_dynamic(obj));
-  }
-};
-
-/* Allocates memory */
-cell factor_vm::instances(cell type) {
-  primitive_full_gc();
-  object_accumulator accum(type);
-  each_object(accum);
-  return std_vector_to_array(accum.objects);
+  };
+  each_object(object_accumulator);
+  return std_vector_to_array(objects);
 }
 
-/* Allocates memory */
+// Allocates memory
 void factor_vm::primitive_all_instances() {
   ctx->push(instances(TYPE_COUNT));
 }