-- This file is part of SmartEiffel The GNU Eiffel Compiler.
-- Copyright (C) 1994-2002 LORIA - INRIA - U.H.P. Nancy 1 - FRANCE
-- Dominique COLNET and Suzanne COLLIN - SmartEiffel@loria.fr
-- http://SmartEiffel.loria.fr
-- SmartEiffel is free software; you can redistribute it and/or modify it
-- under the terms of the GNU General Public License as published by the Free
-- Software Foundation; either version 2, or (at your option) any later
-- version. SmartEiffel is distributed in the hope that it will be useful,but
-- WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-- for more details. You should have received a copy of the GNU General
-- Public License along with SmartEiffel; see the file COPYING. If not,
-- write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-- Boston, MA 02111-1307, USA.
--
class GC_HANDLER
--
-- GARBAGE_COLLECTOR_HANDLER
--
inherit GLOBALS
creation make
feature
is_off: BOOLEAN
-- True when the Garbage Collector is not produced.
info_flag: BOOLEAN
-- True when Garbage Collector Information need to be printed.
feature {NONE}
make is
do
end
feature {ACE,COMPILE_TO_C}
no_gc is
do
is_off := true
info_flag := false
ensure
is_off
not info_flag
end
set_info_flag is
do
is_off := false
info_flag := true
ensure
not is_off
info_flag
end
feature {NONE}
compute_ceils is
local
fsoc_count_ceil, rsoc_count_ceil, i: INTEGER
run_class_map: FIXED_ARRAY[RUN_CLASS]
rc: RUN_CLASS
kb_count: INTEGER
do
run_class_map := smart_eiffel.get_run_class_map
from
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
if rc.at_run_time then
if rc.current_type.is_native_array then
rsoc_count_ceil := rsoc_count_ceil + 1
else
fsoc_count_ceil := fsoc_count_ceil + 1
end
end
i := i - 1
end
fsoc_count_ceil := 4 * fsoc_count_ceil
kb_count := fsoc_count_ceil * (fsoc_size // 1024)
if kb_count < 256 then
fsoc_count_ceil := 256 // (fsoc_size // 1024)
end
rsoc_count_ceil := 3 * rsoc_count_ceil
kb_count := rsoc_count_ceil * (rsoc_size // 1024)
if kb_count < 256 then
rsoc_count_ceil := 256 // (rsoc_size // 1024)
end
cpp.put_extern6(once "unsigned int fsoc_count_ceil",fsoc_count_ceil)
cpp.put_extern6(once "unsigned int rsoc_count_ceil",rsoc_count_ceil)
end
feature {E_TYPE}
memory_dispose(code: STRING; o: STRING; run_class: RUN_CLASS) is
-- Append in `code' the extra C code for the MEMORY.dispose
-- call if any.
require
not run_class.current_type.is_expanded
not run_class.current_type.is_native_array
local
rf3: RUN_FEATURE_3; no_check: BOOLEAN
do
rf3 := run_class.get_memory_dispose
if rf3 /= Void then
code.append(once "if((")
code.append(o)
code.append(once "->header.flag)==FSOH_UNMARKED){%N")
no_check := ace.no_check
if no_check then
code.append(
once "[
se_frame_descriptor gcd={"Garbage Collector at work.\n"
"dispose called (during sweep phase)",0,0,"",1};
se_dump_stack ds = {NULL,NULL,0,NULL,NULL};
ds.fd=&gcd;
ds.caller=se_dst;
]")
rf3.c_set_dump_stack_top_in(code, once "&ds", fz_link)
end
code.extend('r')
run_class.id.append_in(code)
rf3.name.mapping_c_in(code)
code.extend('(')
if no_check then
code.append(once "&ds,")
end
if no_check or else rf3.use_current then
code.extend('(')
run_class.current_type.c_type_for_target_in(code)
code.extend(')')
code.append(o)
end
code.append(fz_14)
if no_check then
rf3.c_set_dump_stack_top_in(code, once "ds.caller", fz_unlink)
end
code.extend('}')
end
end
feature {C_PRETTY_PRINTER}
customize_c_runtime is
do
if not is_off then
cpp.macro_def(once "FSOC_SIZE",fsoc_size)
cpp.macro_def(once "RSOC_SIZE",rsoc_size)
cpp.sys_runtime_h_and_c(fz_gc_lib)
end
end
initialize_runtime is
do
if not is_off then
cpp.put_string(
once "gcmt=((mch**)se_malloc((gcmt_max+1)*sizeof(void*)));%N%
%stack_bottom=((void**)(&argc));%N")
end
end
gc_info_before_exit is
require
cpp.on_c
do
if is_off then
elseif info_flag then
cpp.put_string(
once "fprintf(SE_GCINFO,%"==== Last GC before exit ====\n%");%N%
%gc_start();%N")
end
if not is_off and then dispose_flag then
cpp.put_string(once "gc_dispose_before_exit();%N")
end
end
feature {SMART_EIFFEL}
define1 is
require
not is_off
do
if smart_eiffel.scoop then
fatal_error("The Garbage Collector cannot currently be used with SCOOP.")
end
echo.put_string(once "Adding Garbage Collector.%N")
--
compute_ceils
cpp.swap_on_h
end
define2 is
require
not is_off
local
i: INTEGER; rc: RUN_CLASS; run_class_map: FIXED_ARRAY[RUN_CLASS]
root_type: E_TYPE
do
run_class_map := smart_eiffel.get_run_class_map
root_type := smart_eiffel.root_procedure.current_type
once_manifest_string_pool.define_manifest_string_mark
body.clear
once_routine_pool.gc_mark_in(body)
cpp.put_c_function(once "void once_function_mark(void)",body)
system_tools.put_mark_stack_and_registers
define_gc_start(root_type,run_class_map)
echo.put_string(once "GC support (gc_define1 step).%N")
cpp.swap_on_h
from
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
rc.gc_define1
i := i - 1
end
echo.put_string(once "GC support (gc_define2 step).%N")
cpp.swap_on_c
from
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
rc.gc_define2
i := i - 1
end
from
i := switch_list.upper
until
i < 0
loop
switch_for(switch_list.item(i))
i := i - 1
end
if info_flag then
define_gc_info(run_class_map)
end
ensure
smart_eiffel.magic_count = old smart_eiffel.magic_count
end
feature {RUN_CLASS}
falling_down(run_class: RUN_CLASS) is
local
rf3: RUN_FEATURE_3
do
if not is_off then
rf3 := run_class.get_memory_dispose
if rf3 /= Void then
dispose_flag := true
end
end
end
feature {CREATE_INSTRUCTION,C_PRETTY_PRINTER,TYPE_BIT_REF,TYPE_TUPLE}
declare_allocate_n(rc: RUN_CLASS) is
-- Declare variable `n' and then allocate `n' with an object of `rc'.
-- (This is only a basic allocation, without the creation
-- procedure call.)
require
rc.at_run_time
rc.current_type.is_reference
cpp.on_c
local
my_buffer: STRING
do
body.clear
body.extend('T')
rc.id.append_in(body)
body.extend('*')
allocation_in_(once "n",body,rc,Void)
if rc.current_type.is_separate then
my_buffer := once " "
my_buffer.clear
my_buffer.append(once "(n->ref)")
allocation_in_(my_buffer, body,
rc.current_type.local_from_separate.run_class,
once "se_current_subsystem_thread()")
end
cpp.put_string(body)
end
feature {RUN_CLASS,C_PRETTY_PRINTER,ASSIGNMENT_HANDLER,CREATE_EXPRESSION}
allocation_of(var: STRING; rc: RUN_CLASS) is
-- Basic allocation in the already declared C variable `var' of
-- an object of `rc'. (This is only a basic allocation, without
-- the creation procedure call.)
require
var /= Void
rc.at_run_time
rc.current_type.is_reference
cpp.on_c
do
body.clear
allocation_in_(var,body,rc,Void)
cpp.put_string(body)
end
allocation_of_ref(var: STRING; rc: RUN_CLASS; source_type: E_TYPE) is
-- Basic allocation in the already declared C variable `var' of
-- an object of `rc'. (This is only a basic allocation, without
-- the creation procedure call.)
-- There is no creation of a separate processor.
require
var /= Void
rc.at_run_time
cpp.on_c
do
body.clear
allocation_in_(var,body,rc, once "se_current_subsystem_thread()")
check
rc.current_type.is_separate
end
body.append(once "destination->ref=(")
source_type.c_type_for_target_in(body)
body.append(once ")source;%N")
cpp.put_string(body)
end
feature {RUN_CLASS,ONCE_MANIFEST_STRING_POOL}
allocation_in(var, buffer: STRING; rc: RUN_CLASS) is
-- Same as `allocation_of' but in the provided C code `buffer'.
require
var /= Void
rc.at_run_time
rc.current_type.is_reference
do
allocation_in_(var, buffer, rc, Void)
end
feature {SEPARATE_TOOLS}
new_separate(rc: RUN_CLASS; subsystem: STRING) is
do
body.clear
allocation_in_(once "n", body, rc, subsystem)
cpp.put_string(body)
end
feature {NONE}
allocation_in_(var, buffer: STRING; rc: RUN_CLASS; subsystem: STRING) is
-- `subsystem' may be Void (if we must start a new separate processor)
-- otherwise, the given `subsystem' is assigned to the object.
require
var /= Void
rc.at_run_time
rc.current_type.is_reference
local
ct: E_TYPE; id: INTEGER
do
ct := rc.current_type
id := rc.id
buffer.append(var)
buffer.extend('=')
if is_off then
buffer.append(fz_b7)
id.append_in(buffer)
if ct.need_c_struct then
buffer.append(once "*)se_malloc(sizeof(*")
buffer.append(var)
buffer.append(once "))/*")
rc.c_sizeof.append_in(buffer)
buffer.append(once "*/);%N*")
buffer.append(var)
buffer.append(once "=M")
id.append_in(buffer)
else
-- Object has no attributes :
buffer.append(once "*)se_malloc(1))")
end
else
buffer.append(fz_new)
id.append_in(buffer)
buffer.append(fz_c_no_args_function)
end
buffer.extend(';')
buffer.extend('%N')
if rc.current_type.is_separate then
if subsystem = Void then
-- Create a new subsystem (and start its processor):
buffer.append(var)
buffer.append(
once "->subsystem=se_new_subsystem(SE_SCOOP_THREAD_TYPE,%"")
buffer.append(rc.run_time_mark)
buffer.append(once "%");%N")
else
-- Attach the current subsystem reference:
buffer.append(var)
buffer.append(once "->subsystem=")
buffer.append(subsystem)
buffer.append(once ";%N")
end
end
end
feature {ONCE_MANIFEST_STRING_POOL}
new_manifest_string_in(c_code: STRING; string_at_run_time: BOOLEAN) is
-- Code to create a new Manifest STRING in the "s" local C variable.
do
if is_off or else not string_at_run_time then
c_code.append(once "s=((T7*)se_malloc(sizeof(T7)));%N")
if string_at_run_time and then type_string.run_class.is_tagged then
c_code.append(once "s->id=7;%N")
end
else
c_code.append(once "s=new7();%N")
end
end
new_native9_in(c_code: STRING; string_at_run_time: BOOLEAN) is
do
if is_off or else not string_at_run_time then
c_code.append(once "se_malloc")
else
c_code.append(fz_new)
c_code.extend('9')
end
end
feature
mark_for(c_code: STRING; entity: STRING; rc: RUN_CLASS) is
-- Add `c_code' to mark `entity' of class `rc'.
require
not is_off
rc.current_type.need_gc_mark_function
local
ct: E_TYPE; run_time_set: RUN_TIME_SET
do
run_time_set := rc.run_time_set
if run_time_set.count >= 1 then
ct := rc.current_type
if ct.is_reference or else ct.is_native_array then
c_code.append(once "if(NULL!=")
c_code.append(entity)
c_code.extend(')')
end
if run_time_set.count > 1 and not ct.is_expanded then
-- **********************
-- Note: I don't understand why this fix (provided by Alain
-- Le_Guennec) can be useful because, as far as I know, an
-- expanded class must not have more than one runnable.
-- *** Fri Aug 15 2000, DC
cpp.incr_switched_call_count
if not switch_list.fast_has(rc) then
switch_list.add_last(rc)
end
c_code.extend('X')
ct.gc_mark_in(c_code)
else
cpp.incr_direct_call_count
ct := run_time_set.first.current_type
ct.gc_mark_in(c_code)
end
c_code.extend('(')
if ct.is_reference then
c_code.extend('(')
if run_time_set.count > 1 then
c_code.append(once "T0*")
else
ct.c_type_for_target_in(c_code)
end
c_code.extend(')')
elseif ct.is_user_expanded then
c_code.extend('&')
end
c_code.extend('(')
c_code.append(entity)
c_code.append(fz_16)
end
end
feature {NONE}
switch_list: FIXED_ARRAY[RUN_CLASS] is
-- For which there is a switching function.
once
create Result.with_capacity(128)
end
switch_for(rc: RUN_CLASS) is
local
ct: E_TYPE; run_time_set: RUN_TIME_SET
do
header.clear
header.append(fz_void)
header.extend(' ')
header.extend('X')
ct := rc.current_type
ct.gc_mark_in(header)
header.extend('(')
header.append(fz_t0_star)
header.extend('o')
header.extend(')')
body.clear
run_time_set := rc.run_time_set
body.append(once "{int i=o->id;%N")
c_dicho(run_time_set,1,run_time_set.count)
body.extend('}')
cpp.put_c_function(header,body)
end
c_dicho(run_time_set: RUN_TIME_SET; bi, bs: INTEGER) is
-- Produce dichotomic inspection code for Current id.
require
bi <= bs
local
m: INTEGER; rc: RUN_CLASS
do
if bi = bs then
rc := run_time_set.item(bi)
rc.current_type.gc_mark_in(body)
body.extend('(')
body.extend('(')
body.extend('T')
rc.id.append_in(body)
body.extend('*')
body.extend(')')
body.extend('o')
body.extend(')')
body.append(fz_00)
else
m := (bi + bs) // 2
rc := run_time_set.item(m)
body.append(once "if (i <= ")
rc.id.append_in(body)
body.append(once ") {%N")
c_dicho(run_time_set,bi,m)
body.append(fz_67)
c_dicho(run_time_set,m + 1,bs)
body.extend('}')
end
end
just_before_mark(run_class_map: FIXED_ARRAY[RUN_CLASS]) is
require
not is_off
local
i: INTEGER
rc: RUN_CLASS
do
from
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
rc.just_before_gc_mark_in(body)
i := i - 1
end
end
define_gc_info(run_class_map: FIXED_ARRAY[RUN_CLASS]) is
require
info_flag
local
i: INTEGER; rc: RUN_CLASS
do
header.copy(once "void gc_info(void)")
body.clear
body.append(once "fprintf(SE_GCINFO,%"--------------------\n%");%N")
from
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
rc.gc_info_in(body)
i := i - 1
end
agent_pool.gc_info_in(body)
body.append(
once "fprintf(SE_GCINFO,%"C-stack=%%d %",gc_stack_size());%N%
%fprintf(SE_GCINFO,%"main-table=%%d/%%d %",gcmt_used,gcmt_max);%N%
%fprintf(SE_GCINFO,%"fsoc:%%d(%",fsoc_count);%N%
%fprintf(SE_GCINFO,%"free=%%d %",fsocfl_count());%N%
%fprintf(SE_GCINFO,%"ceil=%%d) %",fsoc_count_ceil);%N%
%fprintf(SE_GCINFO,%"rsoc:%%d(%",rsoc_count);%N%
%fprintf(SE_GCINFO,%"ceil=%%d)\n%",rsoc_count_ceil);%N%
%fprintf(SE_GCINFO,%"GC called %%d time(s)\n%",collector_counter);%N%
%fprintf(SE_GCINFO,%"--------------------\n%");%N")
cpp.put_c_function(header,body)
end
define_gc_start(root_type: E_TYPE; run_class_map: FIXED_ARRAY[RUN_CLASS]) is
do
body.clear
body.append(once "if(gc_is_off)return;%N%
%if(garbage_delayed())return;%N")
body.append(
once "gcmt_tail_addr=(((char*)(gcmt[gcmt_used-1]))+%
%(gcmt[gcmt_used-1])->size);%N%
%((gc")
root_type.id.append_in(body)
body.append(once "*)eiffel_root_object)->header.flag=FSOH_UNMARKED;%N")
just_before_mark(run_class_map)
body.append(fz_gc_mark)
root_type.id.append_in(body)
body.append(once "(eiffel_root_object);%N%
%manifest_string_mark1();%N%
%once_function_mark();%N")
if smart_eiffel.generator_used then
body.append(once "{int i=SE_MAXID-1;%N%
%while(i>=0){%N%
%if(g[i]!=NULL)gc_mark7(g[i]);%N%
%i--;}%N}%N")
end
if smart_eiffel.generating_type_used then
body.append(once "{int i=SE_MAXID-1;%N%
%while(i>=0){%N%
%if(t[i]!=NULL)gc_mark7(t[i]);%N%
%i--;}%N}%N")
end
body.append(once "mark_stack_and_registers();%N%
%gc_sweep();%N%
%collector_counter++;%N")
if info_flag then
body.append(once "gc_info();")
end
cpp.put_c_function(once "void gc_start(void)",body)
end
header: STRING is
once
!!Result.make(64)
end
body: STRING is
once
!!Result.make(512)
end
fsoc_size: INTEGER is 8192; -- Fixed Size Objects Chunks Size.
rsoc_size: INTEGER is 32768; -- ReSizable Objects Chunks Size.
dispose_flag: BOOLEAN
invariant
info_flag implies not is_off
end -- GC_HANDLER