Example #1
0
func TestCorrectness() {
	fmt.Printf("Correctness test\n")

	for ii := 0; ii < 20; ii++ {
		rnd := rand.New(rand.NewSource(time.Now().UnixNano()))
		fmt.Printf("\nTest %v\n", ii)

		arr := make([]int, 64)

		for i := range arr {
			val := rnd.Intn(100) - 16

			if val >= 33 {
				val = 0
			}

			arr[i] = val
		}

		size := len(arr)
		input := make([]byte, size)
		output := make([]byte, size)
		reverse := make([]byte, size)

		for i := range output {
			output[i] = 0x55
		}

		for i := range arr {
			if i == len(arr)/2 {
				input[i] = 255
			} else {
				input[i] = byte(arr[i])
			}
		}

		ZRLT, _ := function.NewZRLT(0)
		fmt.Printf("\nOriginal: ")

		for i := range input {
			if i%100 == 0 {
				fmt.Printf("\n")
			}

			fmt.Printf("%v ", input[i])
		}

		fmt.Printf("\nCoded: ")
		srcIdx, dstIdx, _ := ZRLT.Forward(input, output)

		for i := uint(0); i < dstIdx; i++ {
			if i%100 == 0 {
				fmt.Printf("\n")
			}

			fmt.Printf("%v ", output[i])
		}

		fmt.Printf(" (Compression ratio: %v%%)", dstIdx*100/srcIdx)
		ZRLT, _ = function.NewZRLT(dstIdx)
		ZRLT.Inverse(output, reverse)
		fmt.Printf("\nDecoded: ")
		ok := true

		for i := range input {
			if i%100 == 0 {
				fmt.Printf("\n")
			}

			fmt.Printf("%v ", reverse[i])

			if reverse[i] != input[i] {
				ok = false
			}
		}

		if ok == true {
			fmt.Printf("\nIdentical\n")
		} else {
			fmt.Printf("\nDifferent\n")
			os.Exit(1)
		}
	}
}
Example #2
0
func TestSpeed() {
	iter := 50000
	size := 50000
	fmt.Printf("\n\nSpeed test\n")
	fmt.Printf("Iterations: %v\n", iter)

	for jj := 0; jj < 3; jj++ {
		input := make([]byte, size)
		output := make([]byte, len(input)*2)
		reverse := make([]byte, len(input))

		// Generate random data with runs
		n := 0
		var compressed uint
		var err error
		delta1 := int64(0)
		delta2 := int64(0)

		for n < len(input) {
			val := byte(rand.Intn(7))
			input[n] = val
			n++
			run := rand.Intn(128)
			run -= 100

			for run > 0 && n < len(input) {
				input[n] = val
				n++
				run--
			}
		}

		for ii := 0; ii < iter; ii++ {
			ZRLT, _ := function.NewZRLT(0)
			before := time.Now()

			if _, compressed, err = ZRLT.Forward(input, output); err != nil {
				fmt.Printf("Encoding error: %v\n", err)
				os.Exit(1)
			}

			after := time.Now()
			delta1 += after.Sub(before).Nanoseconds()
		}

		for ii := 0; ii < iter; ii++ {
			ZRLT, _ := function.NewZRLT(compressed)
			before := time.Now()

			if _, _, err = ZRLT.Inverse(output, reverse); err != nil {
				fmt.Printf("Decoding error: %v\n", err)
				os.Exit(1)
			}

			after := time.Now()
			delta2 += after.Sub(before).Nanoseconds()
		}

		idx := -1

		// Sanity check
		for i := range input {
			if input[i] != reverse[i] {
				idx = i
				break
			}
		}

		if idx >= 0 {
			fmt.Printf("Failure at index %v (%v <-> %v)\n", idx, input[idx], reverse[idx])
			os.Exit(1)
		}

		prod := int64(iter) * int64(size)
		fmt.Printf("\nZRLT encoding [ms]: %v", delta1/1000000)
		fmt.Printf("\nThroughput [MB/s]: %d", prod*1000000/delta1*1000/(1024*1024))
		fmt.Printf("\nZRLT decoding [ms]: %v", delta2/1000000)
		fmt.Printf("\nThroughput [MB/s]: %d", prod*1000000/delta2*1000/(1024*1024))
		println()
	}
}