vm/factor.cpp

   1 #include "master.hpp"
   2
   3 namespace factor {
   4
   5 void init_globals() { init_mvm(); }
   6
   7 void factor_vm::default_parameters(vm_parameters* p) {
   8   p->embedded_image = false;
   9   p->image_path = NULL;
  10
  11   p->datastack_size = 32 * sizeof(cell);
  12   p->retainstack_size = 32 * sizeof(cell);
  13
  14 #if defined(FACTOR_PPC)
  15   p->callstack_size = 256 * sizeof(cell);
  16 #else
  17   p->callstack_size = 128 * sizeof(cell);
  18 #endif
  19
  20   p->code_size = 64;
  21   p->young_size = sizeof(cell) / 4;
  22   p->aging_size = sizeof(cell) / 2;
  23   p->tenured_size = 24 * sizeof(cell);
  24
  25   p->max_pic_size = 3;
  26
  27   p->fep = false;
  28   p->signals = true;
  29
  30 #ifdef WINDOWS
  31   p->console = GetConsoleWindow() != NULL;
  32 #else
  33   p->console = true;
  34 #endif
  35
  36   p->callback_size = 256;
  37 }
  38
  39 bool factor_vm::factor_arg(const vm_char* str, const vm_char* arg,
  40                            cell* value) {
  41   int val;
  42   if (SSCANF(str, arg, &val) > 0) {
  43     *value = val;
  44     return true;
  45   } else
  46     return false;
  47 }
  48
  49 void factor_vm::init_parameters_from_args(vm_parameters* p, int argc,
  50                                           vm_char** argv) {
  51   default_parameters(p);
  52   p->executable_path = argv[0];
  53
  54   int i = 0;
  55
  56   for (i = 1; i < argc; i++) {
  57     vm_char* arg = argv[i];
  58     if (STRCMP(arg, STRING_LITERAL("--")) == 0)
  59       break;
  60     else if (factor_arg(arg, STRING_LITERAL("-datastack=%d"),
  61                         &p->datastack_size))
  62       ;
  63     else if (factor_arg(arg, STRING_LITERAL("-retainstack=%d"),
  64                         &p->retainstack_size))
  65       ;
  66     else if (factor_arg(arg, STRING_LITERAL("-callstack=%d"),
  67                         &p->callstack_size))
  68       ;
  69     else if (factor_arg(arg, STRING_LITERAL("-young=%d"), &p->young_size))
  70       ;
  71     else if (factor_arg(arg, STRING_LITERAL("-aging=%d"), &p->aging_size))
  72       ;
  73     else if (factor_arg(arg, STRING_LITERAL("-tenured=%d"), &p->tenured_size))
  74       ;
  75     else if (factor_arg(arg, STRING_LITERAL("-codeheap=%d"), &p->code_size))
  76       ;
  77     else if (factor_arg(arg, STRING_LITERAL("-pic=%d"), &p->max_pic_size))
  78       ;
  79     else if (factor_arg(arg, STRING_LITERAL("-callbacks=%d"),
  80                         &p->callback_size))
  81       ;
  82     else if (STRCMP(arg, STRING_LITERAL("-fep")) == 0)
  83       p->fep = true;
  84     else if (STRCMP(arg, STRING_LITERAL("-nosignals")) == 0)
  85       p->signals = false;
  86     else if (STRNCMP(arg, STRING_LITERAL("-i="), 3) == 0)
  87       p->image_path = arg + 3;
  88     else if (STRCMP(arg, STRING_LITERAL("-console")) == 0)
  89       p->console = true;
  90   }
  91 }
  92
  93 /* Compile code in boot image so that we can execute the startup quotation */
  94 /* Allocates memory */
  95 void factor_vm::prepare_boot_image() {
  96   std::cout << "*** Stage 2 early init... " << std::flush;
  97
  98   compile_all_words();
  99   update_code_heap_words(true);
 100   initialize_all_quotations();
 101   special_objects[OBJ_STAGE2] = true_object;
 102
 103   std::cout << "done" << std::endl;
 104 }
 105
 106 void factor_vm::init_factor(vm_parameters* p) {
 107   /* Kilobytes */
 108   p->datastack_size = align_page(p->datastack_size << 10);
 109   p->retainstack_size = align_page(p->retainstack_size << 10);
 110   p->callstack_size = align_page(p->callstack_size << 10);
 111   p->callback_size = align_page(p->callback_size << 10);
 112
 113   /* Megabytes */
 114   p->young_size <<= 20;
 115   p->aging_size <<= 20;
 116   p->tenured_size <<= 20;
 117   p->code_size <<= 20;
 118
 119   /* Disable GC during init as a sanity check */
 120   gc_off = true;
 121
 122   /* OS-specific initialization */
 123   early_init();
 124
 125   const vm_char* executable_path = vm_executable_path();
 126
 127   if (executable_path)
 128     p->executable_path = executable_path;
 129
 130   if (p->image_path == NULL) {
 131     if (embedded_image_p()) {
 132       p->embedded_image = true;
 133       p->image_path = p->executable_path;
 134     } else
 135       p->image_path = default_image_path();
 136   }
 137
 138   srand((unsigned int)nano_count());
 139   init_ffi();
 140   init_contexts(p->datastack_size, p->retainstack_size, p->callstack_size);
 141   init_callbacks(p->callback_size);
 142   load_image(p);
 143   init_c_io();
 144   init_inline_caching((int)p->max_pic_size);
 145   special_objects[OBJ_CPU] =
 146       allot_alien(false_object, (cell)FACTOR_CPU_STRING);
 147   special_objects[OBJ_OS] = allot_alien(false_object, (cell)FACTOR_OS_STRING);
 148   special_objects[OBJ_CELL_SIZE] = tag_fixnum(sizeof(cell));
 149   special_objects[OBJ_EXECUTABLE] =
 150       allot_alien(false_object, (cell)p->executable_path);
 151   special_objects[OBJ_ARGS] = false_object;
 152   special_objects[OBJ_EMBEDDED] = false_object;
 153   special_objects[OBJ_VM_COMPILER] =
 154       allot_alien(false_object, (cell)FACTOR_COMPILER_VERSION);
 155   special_objects[OBJ_VM_COMPILE_TIME] =
 156       allot_alien(false_object, (cell)FACTOR_COMPILE_TIME);
 157   special_objects[OBJ_VERSION] =
 158       allot_alien(false_object, (cell)FACTOR_STRINGIZE(FACTOR_VERSION));
 159   special_objects[OBJ_GIT_LABEL] =
 160       allot_alien(false_object, (cell)FACTOR_STRINGIZE(FACTOR_GIT_LABEL));
 161
 162   /* We can GC now */
 163   gc_off = false;
 164
 165   if (!to_boolean(special_objects[OBJ_STAGE2]))
 166     prepare_boot_image();
 167
 168   if (p->signals)
 169     init_signals();
 170
 171   if (p->console)
 172     open_console();
 173
 174 }
 175
 176 /* Allocates memory */
 177 void factor_vm::pass_args_to_factor(int argc, vm_char** argv) {
 178   growable_array args(this);
 179
 180   for (fixnum i = 1; i < argc; i++)
 181     args.add(allot_alien(false_object, (cell)argv[i]));
 182
 183   args.trim();
 184   special_objects[OBJ_ARGS] = args.elements.value();
 185 }
 186
 187 void factor_vm::start_factor(vm_parameters* p) {
 188   if (p->fep)
 189     factorbug();
 190
 191   c_to_factor_toplevel(special_objects[OBJ_STARTUP_QUOT]);
 192 }
 193
 194 void factor_vm::stop_factor() {
 195   c_to_factor_toplevel(special_objects[OBJ_SHUTDOWN_QUOT]);
 196 }
 197
 198 char* factor_vm::factor_eval_string(char* string) {
 199   void* func = alien_offset(special_objects[OBJ_EVAL_CALLBACK]);
 200   CODE_TO_FUNCTION_POINTER(func);
 201   return ((char * (*)(char*)) func)(string);
 202 }
 203
 204 void factor_vm::factor_eval_free(char* result) { free(result); }
 205
 206 void factor_vm::factor_yield() {
 207   void* func = alien_offset(special_objects[OBJ_YIELD_CALLBACK]);
 208   CODE_TO_FUNCTION_POINTER(func);
 209   ((void(*)()) func)();
 210 }
 211
 212 void factor_vm::factor_sleep(long us) {
 213   void* func = alien_offset(special_objects[OBJ_SLEEP_CALLBACK]);
 214   CODE_TO_FUNCTION_POINTER(func);
 215   ((void(*)(long)) func)(us);
 216 }
 217
 218 void factor_vm::start_standalone_factor(int argc, vm_char** argv) {
 219   vm_parameters p;
 220   init_parameters_from_args(&p, argc, argv);
 221   init_factor(&p);
 222   pass_args_to_factor(argc, argv);
 223   start_factor(&p);
 224 }
 225
 226 factor_vm* new_factor_vm() {
 227   THREADHANDLE thread = thread_id();
 228   factor_vm* newvm = new factor_vm(thread);
 229   register_vm_with_thread(newvm);
 230   thread_vms[thread] = newvm;
 231
 232   return newvm;
 233 }
 234
 235 VM_C_API void start_standalone_factor(int argc, vm_char** argv) {
 236   factor_vm* newvm = new_factor_vm();
 237   return newvm->start_standalone_factor(argc, argv);
 238 }
 239
 240 }