vm/factor.cpp

   1 #include "master.hpp"
   2
   3 namespace factor
   4 {
   5
   6 factor_vm *vm;
   7 unordered_map<THREADHANDLE, factor_vm*> thread_vms;
   8
   9 void init_globals()
  10 {
  11         init_platform_globals();
  12 }
  13
  14 void factor_vm::default_parameters(vm_parameters *p)
  15 {
  16         p->image_path = NULL;
  17
  18         /* We make a wild guess here that if we're running on ARM, we don't
  19         have a lot of memory. */
  20 #ifdef FACTOR_ARM
  21         p->ds_size = 8 * sizeof(cell);
  22         p->rs_size = 8 * sizeof(cell);
  23
  24         p->code_size = 4;
  25         p->young_size = 1;
  26         p->aging_size = 1;
  27         p->tenured_size = 6;
  28 #else
  29         p->ds_size = 32 * sizeof(cell);
  30         p->rs_size = 32 * sizeof(cell);
  31
  32         p->code_size = 8 * sizeof(cell);
  33         p->young_size = sizeof(cell) / 4;
  34         p->aging_size = sizeof(cell) / 2;
  35         p->tenured_size = 4 * sizeof(cell);
  36 #endif
  37
  38         p->max_pic_size = 3;
  39
  40         p->secure_gc = false;
  41         p->fep = false;
  42         p->signals = true;
  43
  44 #ifdef WINDOWS
  45         p->console = false;
  46 #else
  47         if (this == vm)
  48                 p->console = true;
  49         else
  50                 p->console = false;
  51
  52 #endif
  53
  54         p->callback_size = 256;
  55 }
  56
  57 bool factor_vm::factor_arg(const vm_char* str, const vm_char* arg, cell* value)
  58 {
  59         int val;
  60         if(SSCANF(str,arg,&val) > 0)
  61         {
  62                 *value = val;
  63                 return true;
  64         }
  65         else
  66                 return false;
  67 }
  68
  69 void factor_vm::init_parameters_from_args(vm_parameters *p, int argc, vm_char **argv)
  70 {
  71         default_parameters(p);
  72         p->executable_path = argv[0];
  73
  74         int i = 0;
  75
  76         for(i = 1; i < argc; i++)
  77         {
  78                 vm_char *arg = argv[i];
  79                 if(STRCMP(arg,STRING_LITERAL("--")) == 0) break;
  80                 else if(factor_arg(arg,STRING_LITERAL("-datastack=%d"),&p->ds_size));
  81                 else if(factor_arg(arg,STRING_LITERAL("-retainstack=%d"),&p->rs_size));
  82                 else if(factor_arg(arg,STRING_LITERAL("-young=%d"),&p->young_size));
  83                 else if(factor_arg(arg,STRING_LITERAL("-aging=%d"),&p->aging_size));
  84                 else if(factor_arg(arg,STRING_LITERAL("-tenured=%d"),&p->tenured_size));
  85                 else if(factor_arg(arg,STRING_LITERAL("-codeheap=%d"),&p->code_size));
  86                 else if(factor_arg(arg,STRING_LITERAL("-pic=%d"),&p->max_pic_size));
  87                 else if(factor_arg(arg,STRING_LITERAL("-callbacks=%d"),&p->callback_size));
  88                 else if(STRCMP(arg,STRING_LITERAL("-securegc")) == 0) p->secure_gc = true;
  89                 else if(STRCMP(arg,STRING_LITERAL("-fep")) == 0) p->fep = true;
  90                 else if(STRCMP(arg,STRING_LITERAL("-nosignals")) == 0) p->signals = false;
  91                 else if(STRNCMP(arg,STRING_LITERAL("-i="),3) == 0) p->image_path = arg + 3;
  92                 else if(STRCMP(arg,STRING_LITERAL("-console")) == 0) p->console = true;
  93         }
  94 }
  95
  96 /* Do some initialization that we do once only */
  97 void factor_vm::do_stage1_init()
  98 {
  99         print_string("*** Stage 2 early init... ");
 100         fflush(stdout);
 101
 102         compile_all_words();
 103         userenv[STAGE2_ENV] = true_object;
 104
 105         print_string("done\n");
 106         fflush(stdout);
 107 }
 108
 109 void factor_vm::init_factor(vm_parameters *p)
 110 {
 111         /* Kilobytes */
 112         p->ds_size = align_page(p->ds_size << 10);
 113         p->rs_size = align_page(p->rs_size << 10);
 114         p->callback_size = align_page(p->callback_size << 10);
 115
 116         /* Megabytes */
 117         p->young_size <<= 20;
 118         p->aging_size <<= 20;
 119         p->tenured_size <<= 20;
 120         p->code_size <<= 20;
 121
 122         /* Disable GC during init as a sanity check */
 123         gc_off = true;
 124
 125         /* OS-specific initialization */
 126         early_init();
 127
 128         const vm_char *executable_path = vm_executable_path();
 129
 130         if(executable_path)
 131                 p->executable_path = executable_path;
 132
 133         if(p->image_path == NULL)
 134                 p->image_path = default_image_path();
 135
 136         srand(current_micros());
 137         init_ffi();
 138         init_stacks(p->ds_size,p->rs_size);
 139         init_callbacks(p->callback_size);
 140         load_image(p);
 141         init_c_io();
 142         init_inline_caching(p->max_pic_size);
 143         if(p->signals)
 144                 init_signals();
 145
 146         if(p->console)
 147                 open_console();
 148
 149         init_profiler();
 150
 151         userenv[CPU_ENV] = allot_alien(false_object,(cell)FACTOR_CPU_STRING);
 152         userenv[OS_ENV] = allot_alien(false_object,(cell)FACTOR_OS_STRING);
 153         userenv[CELL_SIZE_ENV] = tag_fixnum(sizeof(cell));
 154         userenv[EXECUTABLE_ENV] = allot_alien(false_object,(cell)p->executable_path);
 155         userenv[ARGS_ENV] = false_object;
 156         userenv[EMBEDDED_ENV] = false_object;
 157
 158         /* We can GC now */
 159         gc_off = false;
 160
 161         if(!to_boolean(userenv[STAGE2_ENV]))
 162                 do_stage1_init();
 163 }
 164
 165 /* May allocate memory */
 166 void factor_vm::pass_args_to_factor(int argc, vm_char **argv)
 167 {
 168         growable_array args(this);
 169         int i;
 170
 171         for(i = 1; i < argc; i++){
 172                 args.add(allot_alien(false_object,(cell)argv[i]));
 173         }
 174
 175         args.trim();
 176         userenv[ARGS_ENV] = args.elements.value();
 177 }
 178
 179 void factor_vm::start_factor(vm_parameters *p)
 180 {
 181         if(p->fep) factorbug();
 182
 183         nest_stacks(NULL);
 184         c_to_factor_toplevel(userenv[BOOT_ENV]);
 185         unnest_stacks();
 186 }
 187
 188 void factor_vm::stop_factor()
 189 {
 190         nest_stacks(NULL);
 191         c_to_factor_toplevel(userenv[SHUTDOWN_ENV]);
 192         unnest_stacks();
 193 }
 194
 195 char *factor_vm::factor_eval_string(char *string)
 196 {
 197         char *(*callback)(char *) = (char *(*)(char *))alien_offset(userenv[EVAL_CALLBACK_ENV]);
 198         return callback(string);
 199 }
 200
 201 void factor_vm::factor_eval_free(char *result)
 202 {
 203         free(result);
 204 }
 205
 206 void factor_vm::factor_yield()
 207 {
 208         void (*callback)() = (void (*)())alien_offset(userenv[YIELD_CALLBACK_ENV]);
 209         callback();
 210 }
 211
 212 void factor_vm::factor_sleep(long us)
 213 {
 214         void (*callback)(long) = (void (*)(long))alien_offset(userenv[SLEEP_CALLBACK_ENV]);
 215         callback(us);
 216 }
 217
 218 void factor_vm::start_standalone_factor(int argc, vm_char **argv)
 219 {
 220         vm_parameters p;
 221         default_parameters(&p);
 222         init_parameters_from_args(&p,argc,argv);
 223         init_factor(&p);
 224         pass_args_to_factor(argc,argv);
 225         start_factor(&p);
 226 }
 227
 228 struct startargs {
 229         int argc;
 230         vm_char **argv;
 231 };
 232
 233 factor_vm *new_factor_vm()
 234 {
 235         factor_vm *newvm = new factor_vm();
 236         register_vm_with_thread(newvm);
 237         thread_vms[thread_id()] = newvm;
 238
 239         return newvm;
 240 }
 241
 242 // arg must be new'ed because we're going to delete it!
 243 void* start_standalone_factor_thread(void *arg)
 244 {
 245         factor_vm *newvm = new_factor_vm();
 246         startargs *args = (startargs*) arg;
 247         int argc = args->argc; vm_char **argv = args->argv;
 248         delete args;
 249         newvm->start_standalone_factor(argc, argv);
 250         return 0;
 251 }
 252
 253 VM_C_API void start_standalone_factor(int argc, vm_char **argv)
 254 {
 255         factor_vm *newvm = new_factor_vm();
 256         vm = newvm;
 257         return newvm->start_standalone_factor(argc,argv);
 258 }
 259
 260 VM_C_API THREADHANDLE start_standalone_factor_in_new_thread(int argc, vm_char **argv)
 261 {
 262         startargs *args = new startargs;
 263         args->argc = argc; args->argv = argv;
 264         return start_thread(start_standalone_factor_thread,args);
 265 }
 266
 267 }