Do not allocate dataset in light mode

randomx.go

@@ -128,6 +128,12 @@ func AllocDataset(flags ...Flag) (*C.randomx_dataset, error) {
 	}
 
 	var dataset *C.randomx_dataset
+
+	//do not allocate without full memory
+	if (SumFlag & FlagFullMEM) == 0 {
+		return dataset, nil
+	}
+
 	dataset = C.randomx_alloc_dataset(SumFlag.toC())
 	if dataset == nil {
 		return nil, errors.New("failed to alloc mem for dataset")
@@ -188,10 +194,6 @@ func CreateVM(cache *C.randomx_cache, dataset *C.randomx_dataset, flags ...Flag)
 		SumFlag = SumFlag | flag
 	}
 
-	if dataset == nil {
-		panic("failed creating vm: using empty dataset")
-	}
-
 	vm := C.randomx_create_vm(SumFlag.toC(), cache, dataset)
 
 	if vm == nil {

randomx_test.go

@@ -44,8 +44,8 @@ func TestAllocCache(t *testing.T) {
 }
 
 func TestAllocDataset(t *testing.T) {
-	ds, _ := AllocDataset(Flag(GetFlags()))
-	cache, _ := AllocCache(Flag(GetFlags()))
+	ds, _ := AllocDataset(Flag(GetFlags()), FlagFullMEM)
+	cache, _ := AllocCache(Flag(GetFlags()), FlagFullMEM)
 
 	seed := make([]byte, 32)
 	InitCache(cache, seed)
@@ -69,7 +69,7 @@ func TestCreateVM(t *testing.T) {
 	InitCache(cache, seed)
 	log.Println("cache initialization finished")
 
-	ds, _ := AllocDataset(Flag(GetFlags()))
+	ds, _ := AllocDataset(Flag(GetFlags()), FlagFullMEM)
 	log.Println("alloc dataset mem finished")
 	count := DatasetItemCount()
 	log.Println("dataset count:", count)
@@ -86,7 +86,34 @@ func TestCreateVM(t *testing.T) {
 	}
 	wg.Wait()
 	log.Println("dataset initialization finished") // too slow when one thread
-	vm, _ := CreateVM(cache, ds, Flag(GetFlags()))
+	vm, _ := CreateVM(cache, ds, Flag(GetFlags()), FlagFullMEM)
+
+	var hashCorrect = make([]byte, hex.DecodedLen(len(tp[2])))
+	_, err := hex.Decode(hashCorrect, tp[2])
+	if err != nil {
+		log.Println(err)
+	}
+
+	hash := CalculateHash(vm, tp[1])
+
+	if bytes.Compare(hash, hashCorrect) != 0 {
+		t.Log(hex.EncodeToString(hash))
+		t.Log(hex.EncodeToString(hashCorrect))
+		t.Fail()
+	}
+}
+
+func TestCreateVMLight(t *testing.T) {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+	var tp = testPairs[pairToTest]
+	cache, _ := AllocCache(Flag(GetFlags()))
+	log.Println("alloc cache mem finished")
+	seed := tp[0]
+	InitCache(cache, seed)
+	log.Println("cache initialization finished")
+
+	log.Println("dataset initialization finished") // too slow when one thread
+	vm, _ := CreateVM(cache, nil, Flag(GetFlags()))
 
 	var hashCorrect = make([]byte, hex.DecodedLen(len(tp[2])))
 	_, err := hex.Decode(hashCorrect, tp[2])
@@ -110,7 +137,40 @@ func TestNewRxVM(t *testing.T) {
 	workerNum := uint32(runtime.NumCPU())
 
 	seed := pair[0]
-	dataset, _ := NewRxDataset(FlagJIT)
+	dataset, _ := NewRxDataset(Flag(GetFlags()), FlagFullMEM)
+	if dataset.GoInit(seed, workerNum) == false {
+		log.Fatal("failed to init dataset")
+	}
+	//defer dataset.Close()
+	fmt.Println("Finished generating dataset in", time.Since(start).Seconds(), "sec")
+
+	vm, _ := NewRxVM(dataset, Flag(GetFlags()), FlagFullMEM)
+	//defer vm.Close()
+
+	blob := pair[1]
+	hash := vm.CalcHash(blob)
+
+	var hashCorrect = make([]byte, hex.DecodedLen(len(pair[2])))
+	_, err := hex.Decode(hashCorrect, pair[2])
+	if err != nil {
+		log.Println(err)
+	}
+
+	if bytes.Compare(hash, hashCorrect) != 0 {
+		t.Log(hex.EncodeToString(hash))
+		t.Log(hex.EncodeToString(hashCorrect))
+		t.Fail()
+	}
+}
+
+func TestNewRxVMLight(t *testing.T) {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+	start := time.Now()
+	pair := testPairs[pairToTest]
+	workerNum := uint32(runtime.NumCPU())
+
+	seed := pair[0]
+	dataset, _ := NewRxDataset(Flag(GetFlags()))
 	if dataset.GoInit(seed, workerNum) == false {
 		log.Fatal("failed to init dataset")
 	}

rxCache.go

@@ -7,7 +7,7 @@ import (
 
 func NewRxCache(flags ...Flag) (*RxCache, error) {
 	cache, err := AllocCache(flags...)
-	if cache == nil {
+	if err != nil {
 		return nil, err
 	}
 

rxDataset.go

@@ -42,6 +42,10 @@ func (ds *RxDataset) GoInit(seed []byte, workerNum uint32) bool {
 		return false
 	}
 
+	if ds.dataset == nil {
+		return true
+	}
+
 	datasetItemCount := DatasetItemCount()
 	var wg sync.WaitGroup
 
@@ -68,6 +72,10 @@ func (ds *RxDataset) CInit(seed []byte, workerNum uint32) bool {
 		return false
 	}
 
+	if ds.dataset == nil {
+		return true
+	}
+
 	FastInitFullDataset(ds.dataset, ds.rxCache.cache, workerNum)
 
 	return true