Add a way to set the number of system threads the VM will use for disvm-exec. Update banner in disvm-exec to indicate DisVM version.

arr committed 10 years ago

Commit 093cfc11 parent 265a2bf3 files · +45 −12Browse files

Unified · Split

3 files

src/exec/main.cpp +39 −6
src/include/disvm.h +5 −0
src/vm/vm.cpp +1 −6

 #include <debug.h>
 #include <exceptions.h>
 #include <vm_asm.h>
+#include <vm_version.h>
 #include "exec.h"
 using namespace disvm;
 struct arg_exception_t : std::runtime_error
 {
-    arg_exception_t(const char *m, const char *arg)
+    arg_exception_t(const char *m, const char *arg = nullptr)
         : std::runtime_error{ m }
         , arg{ arg }
     { }
 struct exec_options
 {
+    exec_options()
+        : debugger{}
+        , enabled_debugger{ false }
+        , quiet_start{ false }
+        , print_help{ false }
+        , sys_thread_count{ vm_t::default_system_thread_count }
+        , thread_quanta{ vm_t::default_thread_quanta }
+    { }
     std::vector<char *> vm_args;
+    uint32_t sys_thread_count;
+    uint32_t thread_quanta;
     bool print_help;
     bool quiet_start;
     bool enabled_debugger;
 void print_banner(const exec_options &options)
 {
+    std::cout << "DisVM " << DISVM_VERSION_MAJOR << '.' << DISVM_VERSION_MINOR << '.' << DISVM_VERSION_PATCH;
+    if (DISVM_VERSION_LABEL != nullptr)
+        std::cout << '-' << DISVM_VERSION_LABEL;
     std::cout
-        << "DisVM\n"
+        << "\n----------------\n"
-        << "----------------\n"
+        << "Debugger enabled: " << std::boolalpha << options.enabled_debugger << "\n"
-        << "Debugger enabled: " << std::boolalpha << options.enabled_debugger << "\n";
+        << "System thread usage: " << options.sys_thread_count << "\n";
     if (options.enabled_debugger)
         std::cout << options.debugger << "\n";
 void print_help()
 {
     std::cout
-        << "Usage: disvm-exec [-d[e|m|x]*] [-q] [-?] <entry module> <args>*\n"
+        << "Usage: disvm-exec [-d[e|m|x]*] [-t <num>] [-q] [-?] <entry module> <args>*\n"
         << "    d - Enable debugger\n"
         << "         e - Break on entry\n"
         << "         m - Break on module load\n"
         << "         x - Break on exception (first chance)\n"
         << "    q - Suppress banner and configuration\n"
+        << "    t - Specify the number of system threads to use (0 < x <= 4)\n"
         << "    ? - Print help\n";
 }
                 break;
             }
         }
+        break;
+    case 't':
+        {
+            auto sys_threads_str = next();
+            if (sys_threads_str == nullptr)
+                throw arg_exception_t{ "System thread requires count" };
+            char *end;
+            auto sys_threads = ::strtol(sys_threads_str, &end, 10);
+            if (sys_threads <= 0 || 4 < sys_threads)
+                throw arg_exception_t{ "Invalid system thread value", sys_threads_str };
+            options.sys_thread_count = sys_threads;
+        }
         break;
     case 'q':
         return EXIT_SUCCESS;
     }
-    vm_t vm;
+    vm_t vm{ options.sys_thread_count, options.thread_quanta };
     if (options.enabled_debugger)
         vm.load_tool(std::make_shared<debugger>(options.debugger));

src/include/disvm.h+5−0

     public: // static
         static const auto root_vm_thread_id = uint32_t{ 0 };
+        static const auto default_system_thread_count = uint32_t{ 1 };
+        // The Inferno implementation defined the thread quanta as 2048 (include/interp.h)
+        static const auto default_thread_quanta = uint32_t{ 2048 };
     public:
         explicit vm_t(
             create_vm_interface_callback_t<runtime::vm_scheduler_t> create_scheduler = nullptr,

src/vm/vm.cpp+1−6

     if (create_scheduler == nullptr)
     {
-        const auto system_thread_count = uint32_t{ 1 };
+        _scheduler = std::make_unique<default_scheduler_t>(*this, default_system_thread_count, default_thread_quanta);
-        // The Inferno implementation defined the thread quanta as 2048 (include/interp.h)
-        const auto thread_quanta = uint32_t{ 2048 };
-        _scheduler = std::make_unique<default_scheduler_t>(*this, system_thread_count, thread_quanta);
     }
     else
     {