SQLite

########################################################################
# Maintenance reminder: the output .js and .wasm files of emcc must be
# in _this_ dir, rather than a subdir, or else parts of the generated
# code get confused and cannot load property (namely, the
# sqlite3.worker.js generated in conjunction with -sWASMFS).
sqlite3.js := sqlite3.js
sqlite3.wasm := sqlite3.wasm
sqlite3-wasm.o := $(dir.api)/sqlite3-wasm.o
$(sqlite3-wasm.o): emcc.cflags += $(SQLITE_OPT)
$(sqlite3-wasm.o): $(dir.top)/sqlite3.c
$(dir.api)/wasm_util.o: emcc.cflags += $(SQLITE_OPT)
sqlite3-wasm.c := $(dir.api)/sqlite3-wasm.c \
    $(dir.jacc)/jaccwabyt_test.c
# ^^^ FIXME (how?): jaccwabyt_test.c is only needed for the test apps,
# so we don't really want to include it in release builds. However, we
# want to test the release builds with those apps, so we cannot simply
# elide that file in release builds. That component is critical to the
# VFS bindings so needs to be tested along with the core APIs.
ifneq (,$(filter -sWASMFS,$(emcc.jsflags)))
  $(sqlite3-wasm.o): emcc.cflags+=-DSQLITE_WASM_OPFS
endif
define WASM_C_COMPILE
$(1).o := $$(subst .c,.o,$(1))
sqlite3.wasm.obj += $$($(1).o)
$$($(1).o): $$(MAKEFILE) $(1)
	$$(emcc.bin) $$(emcc_opt) $$(emcc.flags) $$(emcc.cflags) -c $(1) -o $$@
CLEAN_FILES += $$($(1).o)
endef
$(foreach c,$(sqlite3-wasm.c),$(eval $(call WASM_C_COMPILE,$(c))))
$(sqlite3.js): 
$(sqlite3.js): $(MAKEFILE) $(sqlite3.wasm.obj) \
    EXPORTED_FUNCTIONS.api \
    $(post-js.js)
	$(emcc.bin) -o $(sqlite3.js) $(emcc_opt) $(emcc.flags) $(emcc.jsflags) $(sqlite3.wasm.obj)
	chmod -x $(sqlite3.wasm)
ifneq (,$(wasm-strip))
	$(wasm-strip) $(sqlite3.wasm)
endif
	@ls -la $@ $(sqlite3.wasm)

CLEAN_FILES += $(sqlite3.js) $(sqlite3.wasm)
all: $(sqlite3.js)
wasm: $(sqlite3.js)
# End main Emscripten-based module build
########################################################################

########################################################################
# batch-runner.js...
dir.sql := sql
speedtest1 := ../../speedtest1
speedtest1.c := ../../test/speedtest1.c
speedtest1.sql := $(dir.sql)/speedtest1.sql
$(speedtest1):
	$(MAKE) -C ../.. speedtest1
$(speedtest1.sql): $(speedtest1)
	$(speedtest1) --script $@
batch-runner.list: $(MAKEFILE) $(speedtest1.sql) $(dir.sql)/000-mandelbrot.sql
	bash split-speedtest1-script.sh $(dir.sql)/speedtest1.sql
	ls -1 $(dir.sql)/*.sql | grep -v speedtest1.sql | sort > $@
clean-batch:
	rm -f batch-runner.list $(dir.sql)/speedtest1*.sql
# ^^^ we don't do this along with 'clean' because we clean/rebuild on
# a regular basis with different -Ox flags and rebuilding the batch
# pieces each time is an unnecessary time sink.
batch: batch-runner.list
all: batch
# end batch-runner.js
########################################################################
# speedtest1.js...
emcc.speedtest1-flags := -g $(emcc_opt)
ifneq (0,$(ENABLE_WASMFS))
  emcc.speedtest1-flags += -pthread -sWASMFS -sPTHREAD_POOL_SIZE=2
  emcc.speedtest1-flags += -DSQLITE_WASM_OPFS
endif
emcc.speedtest1-flags += -sINVOKE_RUN=0
#emcc.speedtest1-flags += --no-entry

emcc.speedtest1-flags += -flto
emcc.speedtest1-flags += -sABORTING_MALLOC
emcc.speedtest1-flags += -sINITIAL_MEMORY=128450560
emcc.speedtest1-flags += -sSTRICT_JS

emcc.speedtest1-flags += $(emcc.environment)
emcc.speedtest1-flags += -sMODULARIZE
emcc.speedtest1-flags += -sEXPORT_NAME=sqlite3Speedtest1InitModule
emcc.speedtest1-flags += -Wno-limited-postlink-optimizations
emcc.speedtest1-flags += -sEXPORTED_FUNCTIONS=_main,_malloc,_free,_sqlite3_wasm_vfs_unlink,_sqlite3_wasm_init_opfs
emcc.speedtest1-flags += -sDYNAMIC_EXECUTION=0
emcc.speedtest1-flags += --minify 0

speedtest1.js := speedtest1.js
speedtest1.wasm := $(subst .js,.wasm,$(speedtest1.js))
$(speedtest1.js): emcc.cflags+=
# speedtest1 notes re. sqlite3-wasm.o vs sqlite3-wasm.c: building against
# the latter (predictably) results in a slightly faster binary, but we're
# close enough to the target speed requirements that the 500ms makes a
# difference.
$(speedtest1.js): $(speedtest1.c) $(sqlite3-wasm.c) $(MAKEFILE)
	$(emcc.bin) \
        $(emcc.speedtest1-flags) \
        -I. -I$(dir.top) \
        -DSQLITE_THREADSAFE=0 \
        -DSQLITE_TEMP_STORE=3 \
        -DSQLITE_OMIT_UTF16 \
        -DSQLITE_OMIT_DEPRECATED \
        -DSQLITE_OMIT_SHARED_CACHE \
        '-DSQLITE_DEFAULT_UNIX_VFS="unix-none"' \
        -DSQLITE_SPEEDTEST1_WASM \

        -o $@ $(speedtest1.c) $(sqlite3-wasm.c) -lm
ifneq (,$(wasm-strip))
	$(wasm-strip) $(speedtest1.wasm)
endif
	ls -la $@ $(speedtest1.wasm)

speedtest1: $(speedtest1.js)
all: $(speedtest1.js)
CLEAN_FILES += $(speedtest1.js) $(speedtest1.wasm)
# end speedtest1.js
########################################################################
# fiddle_remote is the remote destination for the fiddle app. It
# must be a [user@]HOST:/path for rsync.
# Note that the target "should probably" contain a symlink of
# index.html -> fiddle.html.
fiddle_remote ?=
ifeq (,$(fiddle_remote))

    /* mkdir() simply hangs when called from fiddle app. Cause is
       not yet determined but the hypothesis is an init-order
       issue. */
    /* Note that this check and is not robust but it will
       hypothetically suffice for the transient wasm-based virtual
       filesystem we're currently running in. */
    const int rc = wasmfs_create_directory(zMountPoint, 0777, pOpfs);
    emscripten_console_logf("OPFS mkdir(%s) rc=%d", zMountPoint, rc);
    if(rc) return SQLITE_IOERR;
  }
  return pOpfs ? 0 : SQLITE_NOMEM;
}
#else
int sqlite3_wasm_init_opfs(void){
  return SQLITE_NOTFOUND;

     arguably more efficient because it will hypothetically free the
     wrapper function quickly.
  */
  target.xCallWrapped = function(fname, resultType, argTypes, ...args){
    if(Array.isArray(arguments[3])) args = arguments[3];
    return target.xWrap(fname, resultType, argTypes||[]).apply(null, args||[]);
  };

  return target;
};

/**
   yawl (Yet Another Wasm Loader) provides very basic wasm loader.
   It requires a config object:

    <div>Output is sent to the dev console because we cannot update the UI while the
      speedtest is running unless/until we move the speedtest to a worker thread.</div>
    <hr>
    <div id='test-output'></div>
    <script src="common/whwasmutil.js"></script>
    <script src="common/SqliteTestUtil.js"></script>
    <script src="speedtest1.js"></script>
    <script>(function(){
        /**
           If this environment contains OPFS, this function initializes it and
           returns the name of the dir on which OPFS is mounted, else it returns
           an empty string.
        */
        const opfsDir = function f(wasmUtil){
          if(undefined !== f._) return f._;
          const pdir = '/persistent';
          if( !self.FileSystemHandle
              || !self.FileSystemDirectoryHandle
              || !self.FileSystemFileHandle){
            return f._ = "";
          }
          try{
            if(0===wasmUtil.xCallWrapped(
              'sqlite3_wasm_init_opfs', 'i32', ['string'], pdir
            )){
              return f._ = pdir;
            }else{
              return f._ = "";
            }
          }catch(e){
            // sqlite3_wasm_init_opfs() is not available
            return f._ = "";
          }
        };
        opfsDir._ = undefined;

        const eOut = document.querySelector('#test-output');
        const log2 = async function(cssClass,...args){
          const ln = document.createElement('div');
          if(cssClass) ln.classList.add(cssClass);
          ln.append(document.createTextNode(args.join(' ')));
          eOut.append(ln);
          //this.e.output.lastElementChild.scrollIntoViewIfNeeded();
        };
        const doHtmlOutput = false
        /* can't update DOM while speedtest is running unless we run
           speedtest in a worker thread. */;
        const log = (...args)=>{
          console.log(...args);
          if(doHtmlOutput) log2('', ...args);
        };
        const logErr = function(...args){
          console.error(...args);
          if(doHtmlOutput) log2('error', ...args);
        };

        const runTests = function(EmscriptenModule){
          console.log("Module inited.",EmscriptenModule);
          const wasm = {
            exports: EmscriptenModule.asm,
            alloc: (n)=>EmscriptenModule._malloc(n),
            dealloc: (m)=>EmscriptenModule._free(m),
            memory: EmscriptenModule.asm.memory || EmscriptenModule.wasmMemory
          };

          //console.debug('wasm =',wasm);
          self.WhWasmUtilInstaller(wasm);
          const unlink = wasm.xWrap("sqlite3_wasm_vfs_unlink", "int", ["string"]);
          const pDir = opfsDir(wasm);
          if(pDir){
            console.warn("Persistent storage:",pDir);
          }
          const scope = wasm.scopedAllocPush();
          const dbFile = 0 ? "" : pDir+"/speedtest1.db";
          try{

            const argv = [
              // TODO: accept flags via URL arguments and/or a
              // UI control. A multi-SELECT element should do
              // nicely.
              "speedtest1",
              "--singlethread",
              //"--stats",
              "--memdb", // note that memdb trumps the filename arg
              dbFile
            ];
            console.log("argv =",argv);
            wasm.xCall('__main_argc_argv', argv.length,
                       wasm.scopedAllocMainArgv(argv));
          }finally{
            wasm.scopedAllocPop(scope);
            if(pDir) unlink(dbFile);
          }
        };

        self.sqlite3TestModule.print = log;
        self.sqlite3TestModule.printErr = logErr;
        sqlite3Speedtest1InitModule(self.sqlite3TestModule).then(function(M){
          setTimeout(()=>runTests(M), 100);
        });
      })();
    </script>
  </body>