// Allocates memory
void factor_vm::primitive_get_samples() {
if (atomic::load(&sampling_profiler_p) || samples.empty()) {
ctx->push(false_object);
} else {
data_root<array> samples_array(allot_array(samples.size(), false_object),
this);
std::vector<profiling_sample>::const_iterator from_iter = samples.begin();
cell to_i = 0;
for (; from_iter != samples.end(); ++from_iter, ++to_i) {
data_root<array> sample(allot_array(7, false_object), this);
set_array_nth(sample.untagged(), 0,
tag_fixnum(from_iter->counts.sample_count));
set_array_nth(sample.untagged(), 1,
tag_fixnum(from_iter->counts.gc_sample_count));
set_array_nth(sample.untagged(), 2,
tag_fixnum(from_iter->counts.jit_sample_count));
set_array_nth(sample.untagged(), 3,
tag_fixnum(from_iter->counts.foreign_sample_count));
set_array_nth(sample.untagged(), 4,
tag_fixnum(from_iter->counts.foreign_thread_sample_count));
set_array_nth(sample.untagged(), 5, from_iter->thread);
cell callstack_size =
from_iter->callstack_end - from_iter->callstack_begin;
data_root<array> callstack(allot_array(callstack_size, false_object),
this);
std::vector<cell>::const_iterator callstacks_begin =
sample_callstacks.begin(),
c_from_iter =
callstacks_begin +
from_iter->callstack_begin,
c_from_iter_end =
callstacks_begin +
from_iter->callstack_end;
cell c_to_i = 0;
for (; c_from_iter != c_from_iter_end; ++c_from_iter, ++c_to_i)
set_array_nth(callstack.untagged(), c_to_i, *c_from_iter);
set_array_nth(sample.untagged(), 6, callstack.value());
set_array_nth(samples_array.untagged(), to_i, sample.value());
}
ctx->push(samples_array.value());
}
}
void init_factor_from_args(F_CHAR *image, int argc, F_CHAR **argv, bool embedded)
{
F_PARAMETERS p;
default_parameters(&p);
if(image) p.image = image;
CELL i;
posix_argc = argc;
posix_argv = safe_malloc(argc * sizeof(F_CHAR*));
posix_argv[0] = safe_strdup(argv[0]);
for(i = 1; i < argc; i++)
{
posix_argv[i] = safe_strdup(argv[i]);
if(factor_arg(argv[i],STR_FORMAT("-datastack=%d"),&p.ds_size));
else if(factor_arg(argv[i],STR_FORMAT("-retainstack=%d"),&p.rs_size));
else if(factor_arg(argv[i],STR_FORMAT("-generations=%d"),&p.gen_count));
else if(factor_arg(argv[i],STR_FORMAT("-young=%d"),&p.young_size));
else if(factor_arg(argv[i],STR_FORMAT("-aging=%d"),&p.aging_size));
else if(factor_arg(argv[i],STR_FORMAT("-tenured=%d"),&p.tenured_size));
else if(factor_arg(argv[i],STR_FORMAT("-codeheap=%d"),&p.code_size));
else if(STRCMP(argv[i],STR_FORMAT("-securegc")) == 0)
p.secure_gc = true;
else if(STRCMP(argv[i],STR_FORMAT("-fep")) == 0)
p.fep = true;
else if(STRNCMP(argv[i],STR_FORMAT("-i="),3) == 0)
p.image = argv[i] + 3;
else if(STRCMP(argv[i],STR_FORMAT("-console")) == 0)
p.console = true;
else if(STRCMP(argv[i],STR_FORMAT("-no-stack-traces")) == 0)
p.stack_traces = false;
}
init_factor(&p);
nest_stacks();
F_ARRAY *args = allot_array(ARRAY_TYPE,argc,F);
for(i = 1; i < argc; i++)
{
REGISTER_UNTAGGED(args);
CELL arg = tag_object(from_native_string(argv[i]));
UNREGISTER_UNTAGGED(args);
set_array_nth(args,i,arg);
}
userenv[ARGS_ENV] = tag_object(args);
const F_CHAR *executable_path = vm_executable_path();
if(!executable_path)
executable_path = argv[0];
userenv[EXECUTABLE_ENV] = tag_object(from_native_string(executable_path));
userenv[EMBEDDED_ENV] = (embedded ? T : F);
if(p.fep)
factorbug();
c_to_factor_toplevel(userenv[BOOT_ENV]);
unnest_stacks();
for(i = 0; i < argc; i++)
free(posix_argv[i]);
free(posix_argv);
}
// Allocates memory
void factor_vm::primitive_array() {
cell fill = ctx->pop();
cell capacity = unbox_array_size();
array* new_array = allot_array(capacity, fill);
ctx->push(tag<array>(new_array));
}
/* push a new array on the stack */
void factor_vm::primitive_array()
{
cell initial = dpop();
cell size = unbox_array_size();
dpush(tag<array>(allot_array(size,initial)));
}