Ways to increase bootup/restart for vscode cmd extension

[istareatscreens]

Hello first I wanted to thank you for making such an awesome project.

In my spare time I created a vscode extension/web client for compiling MASM (Microsoft Macro Assembly Language) HERE. I made this because it is some what of a pain to setup MASM compiling/running, and it is currently I believe impossible to compile MASM on latest OS X.

The major issue I am facing is that it takes roughly 20 seconds to load, which is brutal for development on vscode. I was wondering if you could provide any suggestions on how I could potentially increase the startup time or even reset time (given there is a failure in code that is run)?

I am currently using wine 3.1 and the zip file I am using is set to storage compression (e.g. no compression). I also updated jsZip to the latest version. I am also using the latest compiled version of boxedwine.

I am using the following compile flags with emscripten (ALLOW_MEMORY_GROWTH is required to prevent crashing).
--bind -O3 -g2 -DUSE_MMU -s USE_SDL=2 -DSDL2 -DBOXEDWINE_DISABLE_UI -s ALLOW_MEMORY_GROWTH=1

Unrelated Details

As part of this project I wrote an interface for modifying the file system through local storage although it is rather crude, in that I have to recreate the file in cmd for the filesystem to read the file.

The main code to manage boxwined can be found here

I also modified the mainloop.cpp to allow restart via javascript function call by adding emscripten binding

#include <emscripten/emscripten.h>
#include <emscripten/bind.h>
#include "boxedwine.h"
#include "../../emulation/cpu/common/cpu.h"
#include "knativewindow.h"
#include "knativesystem.h"

static U32 lastTitleUpdate = 0;

void mainloop() {
    U32 startTime = KNativeSystem::getTicks();
    U32 t;
    U32 count=0;
    while (1) {
        bool ran = runSlice();
        
        if (!KNativeWindow::getNativeWindow()->processEvents()) {
            KNativeSystem::cleanup();
            return;
        }
        t = KSystem::getMilliesSinceStart();                
        if (lastTitleUpdate+1000 < t) {
            lastTitleUpdate = t;
            EM_ASM_INT({
                document.title="BoxedWine " + $0 + " MIPS";
            }, getMIPS());
        }
        if (!ran) {
            break;
        }
        if ((KNativeSystem::getTicks()-startTime)>250 || KNativeWindow::windowUpdated) {
            KNativeWindow::windowUpdated = false;
            break;
        }
    };
}

void restartBW() {
    KSystem::destroy();
    emscripten_cancel_main_loop();
    KNativeSystem::cleanup();
    BOXEDWINE_RECORDER_QUIT();
}



class ProcessRun{

private:

static std::shared_ptr<KProcess> process;
static KThread* thread;

public:
	static void runCommand(std::string command);
	static void killProcess();
};

std::shared_ptr<KProcess> ProcessRun::process(nullptr);
KThread* ProcessRun::thread = nullptr;

void ProcessRun::runCommand(std::string command){	
		emscripten_pause_main_loop();
		if(process){
			killProcess();
		}
		process = KProcess::create();
 		process->startProcess("/home/username/.wine/dosdevices/d:", {"/bin/wine", "cmd", "/c", command}, {"HOME=/home/username", "LOGNAME=username",  "USERNAME=username", "USER=username", "PWD=/home/username/.wine/dosdevices/d:", "DISPLAY=:0", "PATH=/bin:/usr/bin:/usr/local/bin"}, 1, 1000, 1, 1000);
		
		emscripten_resume_main_loop();
}

void ProcessRun::killProcess(){
		klog(("process killed: " +std::to_string(process->id)).c_str());
		KSystem::kill(process->id,0);
		KSystem::eraseProcess(process->id);
		KSystem::tgkill(process->groupId, thread->id, 0);
		process->exitgroup(0);
		process->exit(0);
		process = nullptr;
}

bool doMainLoop() {
    EM_ASM(
#ifndef SDL2
            SDL.defaults.copyOnLock = false;
            SDL.defaults.discardOnLock = true;
#endif
            //SDL.defaults.opaqueFrontBuffer = false;
    );
    emscripten_set_main_loop(mainloop, 0, 1);
    return false;
}

EMSCRIPTEN_BINDINGS(bwAPI) {
    emscripten::function("restartBW", &restartBW);
    emscripten::class_<ProcessRun>("ProcessRun")
   .constructor<>()
   .class_function("runCommand", &ProcessRun::runCommand)
   .class_function("killProcess",&ProcessRun::killProcess);
}

[kevodwyer]

Cool project! I will reply with ideas when i have had some time to digest the changes more

[kevodwyer]

I can see in src/assets/boxedwine.zip you have a boxedwine filesystem that is 235 MiB.
A minimal file system to runtime the command line should be closer to around 20MiB when zipped. The number of files is likely to be a contributing factor to the loading time. The unzipping itself should not be a big issue (and unzipping is handled by BrowserFS and not JSZip).
There is an option in emscripten on the Module object to report what files are loaded:
Module.logReadFiles
scan the browser console to see output.

You could also use the 'boxedwine-shell-simple.js' file rather than boxedwine-shell.js. it will not make it faster, but you should be able to debug/modify it more easily.

BrowserS may be more of a hindrance than a help. You could manually copy the wine files directly into the emscripten filesystem. Alternatively populate BrowserFS.FileSystem.LocalStorage(). There is code in boxedwine-shell.js that you may be able to reuse.

Hopefully this helps - Sorry for taking so long to reply

[dr-vortex]

Hi @kevodwyer, I'm the maintainer of BrowserFS. I'd like to let you know that BrowserFS has been deprecated. You can read more about that on the BrowserFS readme (https://github.com/jvilk/BrowserFS). ZenFS is an updated and active fork that I created.