Porting to Wasm

.gitignore

@@ -7,3 +7,8 @@ x64/
 Release/
 Debug/
 build/
+*.wasm
+*.wat
+.idea/*
+cmake-build-debug/*
+wasi-sdk/*

CMakeLists.txt

@@ -49,6 +49,7 @@ src/superscalar.cpp
 src/vm_compiled.cpp
 src/vm_interpreted_light.cpp
 src/argon2_core.c
+        src/launcher.cpp
 src/blake2_generator.cpp
 src/instructions_portable.cpp
 src/reciprocal.c
@@ -219,6 +220,13 @@ target_link_libraries(randomx-benchmark
   PRIVATE randomx
   PRIVATE ${CMAKE_THREAD_LIBS_INIT})
 
+add_executable(runner
+        src/tests/api-example1.c
+        )
+target_link_libraries(runner
+        PRIVATE randomx
+        PRIVATE ${CMAKE_THREAD_LIBS_INIT})
+
 include(CheckCXXSourceCompiles)
 check_cxx_source_compiles("
 #include <cstdint>

Dockerfile

@@ -0,0 +1,14 @@
+FROM ubuntu:20.04
+
+RUN apt update \
+ && DEBIAN_FRONTEND=noninteractive TZ=Etc/UTC apt-get -y install tzdata \
+ && apt install -y ca-certificates \
+    curl \
+    git \
+    make \
+    pkg-config \
+    libtinfo6
+
+VOLUME /code
+WORKDIR /code
+ENTRYPOINT /code/entrypoint.sh

Makefile

@@ -0,0 +1,43 @@
+TARGET = randomx
+CXX = ./wasi-sdk/bin/clang++
+SYSROOT = ./wasi-sdk/share/wasi-sysroot
+TARGET_TRIPLE = wasm32-wasi
+CFLAGS = -fvisibility=hidden
+LDFLAGS = -Wl,--demangle,--allow-undefined
+EXPORT_FUNCS = \
+	--export=test_randomx
+
+RANDOMX_SRC = \
+	src/launcher.cpp\
+	src/randomx.cpp\
+	src/vm_interpreted_light.cpp\
+	src/vm_interpreted.cpp\
+	src/virtual_machine.cpp\
+	src/dataset.cpp\
+	src/argon2_core.c\
+	src/aes_hash.cpp\
+	src/soft_aes.cpp\
+	src/reciprocal.c\
+	src/allocator.cpp\
+	src/superscalar.cpp\
+	src/instructions_portable.cpp\
+	src/bytecode_machine.cpp\
+	src/argon2_ref.c\
+	src/blake2/blake2b.c\
+	src/blake2_generator.cpp
+
+RANDOMX_FLAGS = \
+	-fno-exceptions
+
+.PHONY: default all clean
+
+default: $(TARGET)
+all: default
+
+$(TARGET): $(RANDOMX_SRC)
+	$(CXX) -O3 --sysroot=$(SYSROOT) --target=$(TARGET_TRIPLE) $(RANDOMX_FLAGS) $(CFLAGS) $(LDFLAGS) -Wl,$(EXPORT_FUNCS) $^ -o $@.wasm
+
+.PRECIOUS: $(TARGET)
+
+clean:
+	-rm -f $(TARGET).wasm

docker-compose.yml

@@ -0,0 +1,8 @@
+version: '3'
+services:
+  randomx_wasm:
+    build:
+      context: .
+    container_name: randomx_wasm_builder1
+    volumes:
+     - ./:/code

entrypoint.sh

@@ -0,0 +1,5 @@
+export PATH="${PATH}:/root/.cargo/bin:/root/.local/bin"
+curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-20/wasi-sdk-20.0-linux.tar.gz | tar xz -C .
+rm -rf wasi-sdk
+mv -f wasi-sdk-* wasi-sdk
+make

src/allocator.cpp

@@ -36,23 +36,29 @@ namespace randomx {
 
 	template<size_t alignment>
 	void* AlignedAllocator<alignment>::allocMemory(size_t count) {
-		void *mem = rx_aligned_alloc(count, alignment);
-		if (mem == nullptr)
-			throw std::bad_alloc();
+		//void *mem = rx_aligned_alloc(count, alignment);
+    void *mem = malloc(count);
+		if (mem == nullptr) {
+      abort();
+      //throw std::bad_alloc();
+    }
 		return mem;
 	}
 
 	template<size_t alignment>
 	void AlignedAllocator<alignment>::freeMemory(void* ptr, size_t count) {
-		rx_aligned_free(ptr);
+		//rx_aligned_free(ptr);
+    free(ptr);
 	}
 
 	template struct AlignedAllocator<CacheLineSize>;
 
 	void* LargePageAllocator::allocMemory(size_t count) {
 		void *mem = allocLargePagesMemory(count);
-		if (mem == nullptr)
-			throw std::bad_alloc();
+		if (mem == nullptr) {
+      abort();
+      //throw std::bad_alloc();
+    }
 		return mem;
 	}
 

src/bytecode_machine.hpp

@@ -208,48 +208,48 @@ namespace randomx {
 			*ibc.idst = temp;
 		}
 
-		static void exe_FSWAP_R(RANDOMX_EXE_ARGS) {
-			*ibc.fdst = rx_swap_vec_f128(*ibc.fdst);
-		}
-
-		static void exe_FADD_R(RANDOMX_EXE_ARGS) {
-			*ibc.fdst = rx_add_vec_f128(*ibc.fdst, *ibc.fsrc);
-		}
-
-		static void exe_FADD_M(RANDOMX_EXE_ARGS) {
-			rx_vec_f128 fsrc = rx_cvt_packed_int_vec_f128(getScratchpadAddress(ibc, scratchpad));
-			*ibc.fdst = rx_add_vec_f128(*ibc.fdst, fsrc);
-		}
-
-		static void exe_FSUB_R(RANDOMX_EXE_ARGS) {
-			*ibc.fdst = rx_sub_vec_f128(*ibc.fdst, *ibc.fsrc);
-		}
-
-		static void exe_FSUB_M(RANDOMX_EXE_ARGS) {
-			rx_vec_f128 fsrc = rx_cvt_packed_int_vec_f128(getScratchpadAddress(ibc, scratchpad));
-			*ibc.fdst = rx_sub_vec_f128(*ibc.fdst, fsrc);
-		}
-
-		static void exe_FSCAL_R(RANDOMX_EXE_ARGS) {
-			const rx_vec_f128 mask = rx_set1_vec_f128(0x80F0000000000000);
-			*ibc.fdst = rx_xor_vec_f128(*ibc.fdst, mask);
-		}
-
-		static void exe_FMUL_R(RANDOMX_EXE_ARGS) {
-			*ibc.fdst = rx_mul_vec_f128(*ibc.fdst, *ibc.fsrc);
-		}
-
-		static void exe_FDIV_M(RANDOMX_EXE_ARGS) {
-			rx_vec_f128 fsrc = maskRegisterExponentMantissa(
-				config,
-				rx_cvt_packed_int_vec_f128(getScratchpadAddress(ibc, scratchpad))
-			);
-			*ibc.fdst = rx_div_vec_f128(*ibc.fdst, fsrc);
-		}
-
-		static void exe_FSQRT_R(RANDOMX_EXE_ARGS) {
-			*ibc.fdst = rx_sqrt_vec_f128(*ibc.fdst);
-		}
+  static void exe_FSWAP_R(RANDOMX_EXE_ARGS) {
+    *ibc.fdst = rx_swap_vec_f128(*ibc.fdst);
+  }
+
+  static void exe_FADD_R(RANDOMX_EXE_ARGS) {
+    *ibc.fdst = rx_add_vec_f128(*ibc.fdst, *ibc.fsrc);
+  }
+
+  static void exe_FADD_M(RANDOMX_EXE_ARGS) {
+    rx_vec_f128 fsrc = rx_cvt_packed_int_vec_f128(getScratchpadAddress(ibc, scratchpad));
+    *ibc.fdst = rx_add_vec_f128(*ibc.fdst, fsrc);
+  }
+
+  static void exe_FSUB_R(RANDOMX_EXE_ARGS) {
+    *ibc.fdst = rx_sub_vec_f128(*ibc.fdst, *ibc.fsrc);
+  }
+
+  static void exe_FSUB_M(RANDOMX_EXE_ARGS) {
+    rx_vec_f128 fsrc = rx_cvt_packed_int_vec_f128(getScratchpadAddress(ibc, scratchpad));
+    *ibc.fdst = rx_sub_vec_f128(*ibc.fdst, fsrc);
+  }
+
+  static void exe_FSCAL_R(RANDOMX_EXE_ARGS) {
+    const rx_vec_f128 mask = rx_set1_vec_f128(0x80F0000000000000);
+    *ibc.fdst = rx_xor_vec_f128(*ibc.fdst, mask);
+  }
+
+  static void exe_FMUL_R(RANDOMX_EXE_ARGS) {
+    *ibc.fdst = rx_mul_vec_f128(*ibc.fdst, *ibc.fsrc);
+  }
+
+  static void exe_FDIV_M(RANDOMX_EXE_ARGS) {
+    rx_vec_f128 fsrc = maskRegisterExponentMantissa(
+      config,
+      rx_cvt_packed_int_vec_f128(getScratchpadAddress(ibc, scratchpad))
+    );
+    *ibc.fdst = rx_div_vec_f128(*ibc.fdst, fsrc);
+  }
+
+  static void exe_FSQRT_R(RANDOMX_EXE_ARGS) {
+    *ibc.fdst = rx_sqrt_vec_f128(*ibc.fdst);
+  }
 
 		static void exe_CBRANCH(RANDOMX_EXE_ARGS) {
 			*ibc.idst += ibc.imm;
@@ -259,7 +259,7 @@ namespace randomx {
 		}
 
 		static void exe_CFROUND(RANDOMX_EXE_ARGS) {
-			rx_set_rounding_mode(rotr(*ibc.isrc, ibc.imm) % 4);
+			//rx_set_rounding_mode(rotr(*ibc.isrc, ibc.imm) % 4);
 		}
 
 		static void exe_ISTORE(RANDOMX_EXE_ARGS) {

src/dataset.cpp

@@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "blake2/endian.h"
 #include "argon2.h"
 #include "argon2_core.h"
-#include "jit_compiler.hpp"
+// #include "jit_compiler.hpp"
 #include "intrin_portable.h"
 
 static_assert(RANDOMX_ARGON_MEMORY % (RANDOMX_ARGON_LANES * ARGON2_SYNC_POINTS) == 0, "RANDOMX_ARGON_MEMORY - invalid value");
@@ -61,8 +61,10 @@ namespace randomx {
 	void deallocCache(randomx_cache* cache) {
 		if (cache->memory != nullptr)
 			Allocator::freeMemory(cache->memory, CacheSize);
+    /*
 		if (cache->jit != nullptr)
 			delete cache->jit;
+     */
 	}
 
 	template void deallocCache<DefaultAllocator>(randomx_cache* cache);
@@ -128,7 +130,8 @@ namespace randomx {
 		randomx::Blake2Generator gen(key, keySize);
 		for (int i = 0; i < RANDOMX_CACHE_ACCESSES; ++i) {
 			randomx::generateSuperscalar(cache->programs[i], gen);
-			for (unsigned j = 0; j < cache->programs[i].getSize(); ++j) {
+
+      for (unsigned j = 0; j < cache->programs[i].getSize(); ++j) {
 				auto& instr = cache->programs[i](j);
 				if ((SuperscalarInstructionType)instr.opcode == SuperscalarInstructionType::IMUL_RCP) {
 					auto rcp = randomx_reciprocal(instr.getImm32());
@@ -141,10 +144,12 @@ namespace randomx {
 
 	void initCacheCompile(randomx_cache* cache, const void* key, size_t keySize) {
 		initCache(cache, key, keySize);
+    /*
 		cache->jit->enableWriting();
 		cache->jit->generateSuperscalarHash(cache->programs, cache->reciprocalCache);
 		cache->jit->generateDatasetInitCode();
 		cache->jit->enableExecution();
+     */
 	}
 
 	constexpr uint64_t superscalarMul0 = 6364136223846793005ULL;

src/dataset.hpp

@@ -92,12 +92,14 @@ namespace randomx {
 	void initDataset(randomx_cache* cache, uint8_t* dataset, uint32_t startBlock, uint32_t endBlock);
 
 	inline randomx_argon2_impl* selectArgonImpl(randomx_flags flags) {
+    /*
 		if (flags & RANDOMX_FLAG_ARGON2_AVX2) {
 			return randomx_argon2_impl_avx2();
 		}
 		if (flags & RANDOMX_FLAG_ARGON2_SSSE3) {
 			return randomx_argon2_impl_ssse3();
 		}
+    */
 		return &randomx_argon2_fill_segment_ref;
 	}
 }

src/instructions_portable.cpp

@@ -139,6 +139,7 @@ void rx_reset_float_state() {
 }
 
 void rx_set_rounding_mode(uint32_t mode) {
+    /*
 	switch (mode & 3) {
 	case RoundDown:
 		setRoundMode_(FE_DOWNWARD);
@@ -155,9 +156,11 @@ void rx_set_rounding_mode(uint32_t mode) {
 	default:
 		UNREACHABLE;
 	}
+     */
 }
 
 uint32_t rx_get_rounding_mode() {
+    /*
 	switch (fegetround()) {
 	case FE_DOWNWARD:
 		return RoundDown;
@@ -170,6 +173,8 @@ uint32_t rx_get_rounding_mode() {
 	default:
 		UNREACHABLE;
 	}
+     */
+    return 0;
 }
 
 #endif

src/intrin_portable.h

@@ -723,11 +723,13 @@ static const char* platformError = "Platform doesn't support hardware AES";
 #include <stdexcept>
 
 FORCE_INLINE rx_vec_i128 rx_aesenc_vec_i128(rx_vec_i128 v, rx_vec_i128 rkey) {
-	throw std::runtime_error(platformError);
+  abort();
+	// throw std::runtime_error(platformError);
 }
 
 FORCE_INLINE rx_vec_i128 rx_aesdec_vec_i128(rx_vec_i128 v, rx_vec_i128 rkey) {
-	throw std::runtime_error(platformError);
+  abort();
+	// throw std::runtime_error(platformError);
 }
 
 #define HAVE_AES 0