From 822a340317d9490991f6d370d89a3b4f2b2d92e1 Mon Sep 17 00:00:00 2001 From: Harikrishnan Shaji Date: Fri, 5 Jul 2024 16:57:36 +0530 Subject: [PATCH 1/6] Run all builtin tests as integration tests --- integration_tests/cairozero_test.go | 111 +++++++++++++--------------- 1 file changed, 50 insertions(+), 61 deletions(-) diff --git a/integration_tests/cairozero_test.go b/integration_tests/cairozero_test.go index 04653c83d..93a0cb3a9 100644 --- a/integration_tests/cairozero_test.go +++ b/integration_tests/cairozero_test.go @@ -54,19 +54,8 @@ func (f *Filter) filtered(testFile string) bool { func TestCairoZeroFiles(t *testing.T) { root1 := "./cairo_zero_hint_tests/" root2 := "./cairo_zero_file_tests/" - - testFiles1, err := os.ReadDir(root1) - require.NoError(t, err) - - testFiles2, err := os.ReadDir(root2) - require.NoError(t, err) - - testFiles := append(testFiles1, testFiles2...) - - testFiles1Map := make(map[string]struct{}, len(testFiles1)) - for _, entry := range testFiles1 { - testFiles1Map[entry.Name()] = struct{}{} - } + root3 := "./builtin_tests/" + roots := []string{root1, root2, root3} // filter is for debugging purposes filter := Filter{} @@ -74,68 +63,68 @@ func TestCairoZeroFiles(t *testing.T) { benchmarkMap := make(map[string][2]int) - for _, dirEntry := range testFiles { - if dirEntry.IsDir() || isGeneratedFile(dirEntry.Name()) { - continue - } + for _, root := range roots { + testFiles, err := os.ReadDir(root) + require.NoError(t, err) - path := filepath.Join(root2, dirEntry.Name()) - if _, found := testFiles1Map[dirEntry.Name()]; found { - path = filepath.Join(root1, dirEntry.Name()) - } + for _, dirEntry := range testFiles { + if dirEntry.IsDir() || isGeneratedFile(dirEntry.Name()) { + continue + } - if !filter.filtered(dirEntry.Name()) { - continue - } + path := filepath.Join(root, dirEntry.Name()) - t.Logf("testing: %s\n", path) + if !filter.filtered(dirEntry.Name()) { + continue + } - compiledOutput, err := compileZeroCode(path) - if err != nil { - t.Error(err) - continue - } + t.Logf("testing: %s\n", path) - elapsedPy, pyTraceFile, pyMemoryFile, err := runPythonVm(dirEntry.Name(), compiledOutput) - if err != nil { - t.Error(err) - continue - } + compiledOutput, err := compileZeroCode(path) + if err != nil { + t.Error(err) + continue + } - elapsedGo, traceFile, memoryFile, _, err := runVm(compiledOutput) - if err != nil { - t.Error(err) - continue - } + elapsedPy, pyTraceFile, pyMemoryFile, err := runPythonVm(dirEntry.Name(), compiledOutput) + if err != nil { + t.Error(err) + continue + } - benchmarkMap[dirEntry.Name()] = [2]int{int(elapsedPy.Milliseconds()), int(elapsedGo.Milliseconds())} + elapsedGo, traceFile, memoryFile, _, err := runVm(compiledOutput) + if err != nil { + t.Error(err) + continue + } - pyTrace, pyMemory, err := decodeProof(pyTraceFile, pyMemoryFile) - if err != nil { - t.Error(err) - continue - } + benchmarkMap[dirEntry.Name()] = [2]int{int(elapsedPy.Milliseconds()), int(elapsedGo.Milliseconds())} - trace, memory, err := decodeProof(traceFile, memoryFile) - if err != nil { - t.Error(err) - continue - } + pyTrace, pyMemory, err := decodeProof(pyTraceFile, pyMemoryFile) + if err != nil { + t.Error(err) + continue + } - if !assert.Equal(t, pyTrace, trace) { - t.Logf("pytrace:\n%s\n", traceRepr(pyTrace)) - t.Logf("trace:\n%s\n", traceRepr(trace)) - } - if !assert.Equal(t, pyMemory, memory) { - t.Logf("pymemory;\n%s\n", memoryRepr(pyMemory)) - t.Logf("memory;\n%s\n", memoryRepr(memory)) + trace, memory, err := decodeProof(traceFile, memoryFile) + if err != nil { + t.Error(err) + continue + } + + if !assert.Equal(t, pyTrace, trace) { + t.Logf("pytrace:\n%s\n", traceRepr(pyTrace)) + t.Logf("trace:\n%s\n", traceRepr(trace)) + } + if !assert.Equal(t, pyMemory, memory) { + t.Logf("pymemory;\n%s\n", memoryRepr(pyMemory)) + t.Logf("memory;\n%s\n", memoryRepr(memory)) + } } + clean(root) } WriteBenchMarksToFile(benchmarkMap) - - clean(root1) - clean(root2) } // Save the Benchmarks for the integration tests in `BenchMarks.txt` From a485fe9576e4ea2230d4142ace6987ba5a63fa01 Mon Sep 17 00:00:00 2001 From: Harikrishnan Shaji Date: Fri, 5 Jul 2024 17:02:20 +0530 Subject: [PATCH 2/6] Fix bitwise infer value bug --- pkg/vm/builtins/bitwise.go | 51 ++++++++++++++++++++------------------ 1 file changed, 27 insertions(+), 24 deletions(-) diff --git a/pkg/vm/builtins/bitwise.go b/pkg/vm/builtins/bitwise.go index 1722b717c..b498a321d 100644 --- a/pkg/vm/builtins/bitwise.go +++ b/pkg/vm/builtins/bitwise.go @@ -60,31 +60,34 @@ func (b *Bitwise) InferValue(segment *memory.Segment, offset uint64) error { var bitwiseValue memory.MemoryValue var bitwiseFelt fp.Element var bitwiseBytes [32]byte - for i := 0; i < 32; i++ { - bitwiseBytes[i] = xBytes[i] & yBytes[i] - } - bitwiseFelt.SetBytes(bitwiseBytes[:]) - bitwiseValue = memory.MemoryValueFromFieldElement(&bitwiseFelt) - if err := segment.Write(xOffset+2, &bitwiseValue); err != nil { - return err - } - for i := 0; i < 32; i++ { - bitwiseBytes[i] = xBytes[i] ^ yBytes[i] - } - bitwiseFelt.SetBytes(bitwiseBytes[:]) - bitwiseValue = memory.MemoryValueFromFieldElement(&bitwiseFelt) - if err := segment.Write(xOffset+3, &bitwiseValue); err != nil { - return err - } - - for i := 0; i < 32; i++ { - bitwiseBytes[i] = xBytes[i] | yBytes[i] - } - bitwiseFelt.SetBytes(bitwiseBytes[:]) - bitwiseValue = memory.MemoryValueFromFieldElement(&bitwiseFelt) - if err := segment.Write(xOffset+4, &bitwiseValue); err != nil { - return err + if bitwiseIndex == 2 { + for i := 0; i < 32; i++ { + bitwiseBytes[i] = xBytes[i] & yBytes[i] + } + bitwiseFelt.SetBytes(bitwiseBytes[:]) + bitwiseValue = memory.MemoryValueFromFieldElement(&bitwiseFelt) + if err := segment.Write(xOffset+2, &bitwiseValue); err != nil { + return err + } + } else if bitwiseIndex == 3 { + for i := 0; i < 32; i++ { + bitwiseBytes[i] = xBytes[i] ^ yBytes[i] + } + bitwiseFelt.SetBytes(bitwiseBytes[:]) + bitwiseValue = memory.MemoryValueFromFieldElement(&bitwiseFelt) + if err := segment.Write(xOffset+3, &bitwiseValue); err != nil { + return err + } + } else if bitwiseIndex == 4 { + for i := 0; i < 32; i++ { + bitwiseBytes[i] = xBytes[i] | yBytes[i] + } + bitwiseFelt.SetBytes(bitwiseBytes[:]) + bitwiseValue = memory.MemoryValueFromFieldElement(&bitwiseFelt) + if err := segment.Write(xOffset+4, &bitwiseValue); err != nil { + return err + } } return nil From eaa972a3407655cec376a3b5662681b318717dab Mon Sep 17 00:00:00 2001 From: Harikrishnan Shaji Date: Fri, 5 Jul 2024 17:50:13 +0530 Subject: [PATCH 3/6] Allow checking for failures --- integration_tests/BenchMarks.txt | 94 +++++++++++++++++------------ integration_tests/cairozero_test.go | 45 ++++++++++---- 2 files changed, 88 insertions(+), 51 deletions(-) diff --git a/integration_tests/BenchMarks.txt b/integration_tests/BenchMarks.txt index 460afc40e..96d92eca4 100644 --- a/integration_tests/BenchMarks.txt +++ b/integration_tests/BenchMarks.txt @@ -1,81 +1,97 @@ =========================================================================================================================== | File | PythonVM (ms) | GoVM (ms) | =========================================================================================================================== -| get_point_from_x.small.cairo | 971 | 125 | +| get_point_from_x.small.cairo | 884 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| is_quad_residue.small.cairo | 963 | 152 | +| memcpy.cairo | 683 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| reduce_v1.small.cairo | 931 | 130 | +| memset.cairo | 701 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_unsigned_div_rem.small.cairo | 1061 | 132 | +| pow.small.cairo | 969 | 147 | --------------------------------------------------------------------------------------------------------------------------- -| set_add.small.cairo | 749 | 117 | +| search_sorted_lower.small.cairo | 733 | 170 | --------------------------------------------------------------------------------------------------------------------------- -| split64.small.cairo | 1014 | 117 | +| split64.small.cairo | 827 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_signedNN.small.cairo | 752 | 114 | +| uint256_signedNN.small.cairo | 865 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| split_felt.small.cairo | 841 | 145 | +| div_mod_n.small.cairo | 859 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| split_int.small.cairo | 1037 | 133 | +| verify_zero.small.cairo | 791 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_add.small.cairo | 921 | 110 | +| verify_ecdsa_signature.small.cairo | 773 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| signed_div_rem.small.cairo | 816 | 117 | +| blake.starknet_with_keccak.cairo | 2127 | 120 | --------------------------------------------------------------------------------------------------------------------------- -| sqrt.small.cairo | 960 | 119 | +| cmp.small.cairo | 903 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_sqrt.small.cairo | 1195 | 115 | +| hintrefs.cairo | 1009 | 129 | --------------------------------------------------------------------------------------------------------------------------- -| assert_not_zero.cairo | 586 | 100 | +| is_zero.small.cairo | 988 | 111 | --------------------------------------------------------------------------------------------------------------------------- -| blake.starknet_with_keccak.cairo | 2498 | 144 | +| uint256_sqrt.small.cairo | 1020 | 114 | --------------------------------------------------------------------------------------------------------------------------- -| import_secp256R1P.small.cairo | 699 | 123 | +| poseidon_test.starknet_with_keccak.cairo| 1386 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| memcpy.cairo | 704 | 124 | +| alloc.cairo | 638 | 238 | --------------------------------------------------------------------------------------------------------------------------- -| unsigned_div_rem.small.cairo | 843 | 118 | +| unsafe_keccak_finalize.small.cairo | 649 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| factorial.cairo | 1161 | 123 | +| split_felt.small.cairo | 812 | 109 | --------------------------------------------------------------------------------------------------------------------------- -| hintrefs.cairo | 676 | 127 | +| uint256_mul_div_mod.small.cairo | 908 | 114 | --------------------------------------------------------------------------------------------------------------------------- -| cmp.small.cairo | 897 | 110 | +| uint256_unsigned_div_rem.small.cairo | 880 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| dict_squash.small.cairo | 1240 | 166 | +| simple.cairo | 626 | 102 | --------------------------------------------------------------------------------------------------------------------------- -| div_mod_n.small.cairo | 921 | 113 | +| bitwise_builtin_test.starknet_with_keccak.cairo| 1474 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| find_element.small.cairo | 939 | 124 | +| ec.small.cairo | 4659 | 165 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_mul_div_mod.small.cairo | 1032 | 119 | +| import_secp256R1P.small.cairo | 821 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| verify_zero.small.cairo | 781 | 112 | +| is_quad_residue.small.cairo | 912 | 127 | --------------------------------------------------------------------------------------------------------------------------- -| ec.small.cairo | 1042 | 129 | +| set_add.small.cairo | 637 | 128 | --------------------------------------------------------------------------------------------------------------------------- -| memset.cairo | 701 | 128 | +| split_int.small.cairo | 728 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| pow.small.cairo | 887 | 112 | +| sqrt.small.cairo | 855 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| search_sorted_lower.small.cairo | 836 | 134 | +| usort.small.cairo | 783 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| alloc.cairo | 666 | 126 | +| fib.cairo | 667 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| simple.cairo | 596 | 110 | +| dict_squash.small.cairo | 813 | 110 | --------------------------------------------------------------------------------------------------------------------------- -| assert_250_bits.small.cairo | 979 | 120 | +| ecdsa_test.starknet_with_keccak.cairo | 1446 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| assert_not_equal.cairo | 638 | 101 | +| assert_not_zero.cairo | 624 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| dict.cairo | 678 | 115 | +| pedersen_test.small.cairo | 677 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| is_positive.small.cairo | 884 | 128 | +| assert_not_equal.cairo | 823 | 128 | --------------------------------------------------------------------------------------------------------------------------- -| usort.small.cairo | 797 | 119 | +| signed_div_rem.small.cairo | 740 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| verify_ecdsa_signature.small.cairo | 758 | 117 | +| uint256_add.small.cairo | 710 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| fib.cairo | 634 | 116 | +| unsigned_div_rem.small.cairo | 856 | 107 | +--------------------------------------------------------------------------------------------------------------------------- +| factorial.cairo | 1163 | 112 | +--------------------------------------------------------------------------------------------------------------------------- +| keccak_test.starknet_with_keccak.cairo| 1446 | 112 | +--------------------------------------------------------------------------------------------------------------------------- +| dict.cairo | 750 | 104 | +--------------------------------------------------------------------------------------------------------------------------- +| find_element.small.cairo | 735 | 106 | +--------------------------------------------------------------------------------------------------------------------------- +| is_positive.small.cairo | 1035 | 108 | +--------------------------------------------------------------------------------------------------------------------------- +| reduce_v1.small.cairo | 892 | 107 | +--------------------------------------------------------------------------------------------------------------------------- +| unsafe_keccak.small.cairo | 661 | 103 | +--------------------------------------------------------------------------------------------------------------------------- +| assert_250_bits.small.cairo | 814 | 104 | =========================================================================================================================== diff --git a/integration_tests/cairozero_test.go b/integration_tests/cairozero_test.go index 93a0cb3a9..f921e1aff 100644 --- a/integration_tests/cairozero_test.go +++ b/integration_tests/cairozero_test.go @@ -51,11 +51,12 @@ func (f *Filter) filtered(testFile string) bool { return false } -func TestCairoZeroFiles(t *testing.T) { - root1 := "./cairo_zero_hint_tests/" - root2 := "./cairo_zero_file_tests/" - root3 := "./builtin_tests/" - roots := []string{root1, root2, root3} +func TestCairoFiles(t *testing.T) { + roots := []string{ + "./cairo_zero_hint_tests/", + "./cairo_zero_file_tests/", + "./builtin_tests/", + } // filter is for debugging purposes filter := Filter{} @@ -72,7 +73,17 @@ func TestCairoZeroFiles(t *testing.T) { continue } - path := filepath.Join(root, dirEntry.Name()) + name := dirEntry.Name() + + errorExpected := false + if name == "range_check.small.cairo" { + errorExpected = true + } else if name == "ecop.starknet_with_keccak.cairo" { + // temporary, being fixed in another PR soon + continue + } + + path := filepath.Join(root, name) if !filter.filtered(dirEntry.Name()) { continue @@ -86,16 +97,26 @@ func TestCairoZeroFiles(t *testing.T) { continue } - elapsedPy, pyTraceFile, pyMemoryFile, err := runPythonVm(dirEntry.Name(), compiledOutput) - if err != nil { - t.Error(err) - continue + elapsedPy, pyTraceFile, pyMemoryFile, err := runPythonVm(name, compiledOutput) + if errorExpected { + // we let the code go on so that we can check if the go vm also raises an error + assert.Error(t, err, path) + } else { + if err != nil { + t.Error(err) + continue + } } elapsedGo, traceFile, memoryFile, _, err := runVm(compiledOutput) - if err != nil { - t.Error(err) + if errorExpected { + assert.Error(t, err, path) continue + } else { + if err != nil { + t.Error(err) + continue + } } benchmarkMap[dirEntry.Name()] = [2]int{int(elapsedPy.Milliseconds()), int(elapsedGo.Milliseconds())} From 7433c6e1877021acb10aa54f69822c4a3032864c Mon Sep 17 00:00:00 2001 From: Harikrishnan Shaji Date: Fri, 5 Jul 2024 17:57:11 +0530 Subject: [PATCH 4/6] Update blake test --- integration_tests/BenchMarks.txt | 94 +++++++++---------- .../blake.starknet_with_keccak.cairo | 42 ++++++++- 2 files changed, 88 insertions(+), 48 deletions(-) diff --git a/integration_tests/BenchMarks.txt b/integration_tests/BenchMarks.txt index 96d92eca4..ce2f8a793 100644 --- a/integration_tests/BenchMarks.txt +++ b/integration_tests/BenchMarks.txt @@ -1,97 +1,97 @@ =========================================================================================================================== | File | PythonVM (ms) | GoVM (ms) | =========================================================================================================================== -| get_point_from_x.small.cairo | 884 | 108 | +| uint256_unsigned_div_rem.small.cairo | 872 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| memcpy.cairo | 683 | 104 | +| unsafe_keccak_finalize.small.cairo | 659 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| memset.cairo | 701 | 104 | +| keccak_test.starknet_with_keccak.cairo| 1304 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| pow.small.cairo | 969 | 147 | +| assert_not_zero.cairo | 678 | 109 | --------------------------------------------------------------------------------------------------------------------------- -| search_sorted_lower.small.cairo | 733 | 170 | +| dict_squash.small.cairo | 1965 | 273 | --------------------------------------------------------------------------------------------------------------------------- -| split64.small.cairo | 827 | 106 | +| split64.small.cairo | 944 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_signedNN.small.cairo | 865 | 104 | +| split_felt.small.cairo | 890 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| div_mod_n.small.cairo | 859 | 105 | +| cmp.small.cairo | 1150 | 111 | --------------------------------------------------------------------------------------------------------------------------- -| verify_zero.small.cairo | 791 | 105 | +| memcpy.cairo | 615 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| verify_ecdsa_signature.small.cairo | 773 | 103 | +| factorial.cairo | 1041 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| blake.starknet_with_keccak.cairo | 2127 | 120 | +| search_sorted_lower.small.cairo | 760 | 109 | --------------------------------------------------------------------------------------------------------------------------- -| cmp.small.cairo | 903 | 108 | +| uint256_signedNN.small.cairo | 863 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| hintrefs.cairo | 1009 | 129 | +| fib.cairo | 666 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| is_zero.small.cairo | 988 | 111 | +| assert_250_bits.small.cairo | 915 | 129 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_sqrt.small.cairo | 1020 | 114 | +| ec.small.cairo | 5145 | 159 | --------------------------------------------------------------------------------------------------------------------------- -| poseidon_test.starknet_with_keccak.cairo| 1386 | 108 | +| get_point_from_x.small.cairo | 869 | 109 | --------------------------------------------------------------------------------------------------------------------------- -| alloc.cairo | 638 | 238 | +| pow.small.cairo | 787 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| unsafe_keccak_finalize.small.cairo | 649 | 103 | +| assert_not_equal.cairo | 783 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| split_felt.small.cairo | 812 | 109 | +| hintrefs.cairo | 671 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_mul_div_mod.small.cairo | 908 | 114 | +| import_secp256R1P.small.cairo | 697 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_unsigned_div_rem.small.cairo | 880 | 108 | +| sqrt.small.cairo | 806 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| simple.cairo | 626 | 102 | +| verify_ecdsa_signature.small.cairo | 937 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| bitwise_builtin_test.starknet_with_keccak.cairo| 1474 | 108 | +| verify_zero.small.cairo | 801 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| ec.small.cairo | 4659 | 165 | +| ecdsa_test.starknet_with_keccak.cairo | 1399 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| import_secp256R1P.small.cairo | 821 | 103 | +| pedersen_test.small.cairo | 636 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| is_quad_residue.small.cairo | 912 | 127 | +| blake.starknet_with_keccak.cairo | 3863 | 136 | --------------------------------------------------------------------------------------------------------------------------- -| set_add.small.cairo | 637 | 128 | +| reduce_v1.small.cairo | 823 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| split_int.small.cairo | 728 | 107 | +| uint256_add.small.cairo | 708 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| sqrt.small.cairo | 855 | 106 | +| uint256_sqrt.small.cairo | 929 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| usort.small.cairo | 783 | 107 | +| poseidon_test.starknet_with_keccak.cairo| 1260 | 146 | --------------------------------------------------------------------------------------------------------------------------- -| fib.cairo | 667 | 103 | +| dict.cairo | 1876 | 109 | --------------------------------------------------------------------------------------------------------------------------- -| dict_squash.small.cairo | 813 | 110 | +| is_positive.small.cairo | 754 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| ecdsa_test.starknet_with_keccak.cairo | 1446 | 108 | +| split_int.small.cairo | 803 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| assert_not_zero.cairo | 624 | 103 | +| uint256_mul_div_mod.small.cairo | 914 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| pedersen_test.small.cairo | 677 | 105 | +| set_add.small.cairo | 690 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| assert_not_equal.cairo | 823 | 128 | +| unsafe_keccak.small.cairo | 698 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| signed_div_rem.small.cairo | 740 | 105 | +| unsigned_div_rem.small.cairo | 819 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_add.small.cairo | 710 | 105 | +| usort.small.cairo | 885 | 112 | --------------------------------------------------------------------------------------------------------------------------- -| unsigned_div_rem.small.cairo | 856 | 107 | +| div_mod_n.small.cairo | 1921 | 150 | --------------------------------------------------------------------------------------------------------------------------- -| factorial.cairo | 1163 | 112 | +| find_element.small.cairo | 889 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| keccak_test.starknet_with_keccak.cairo| 1446 | 112 | +| is_quad_residue.small.cairo | 862 | 124 | --------------------------------------------------------------------------------------------------------------------------- -| dict.cairo | 750 | 104 | +| memset.cairo | 853 | 179 | --------------------------------------------------------------------------------------------------------------------------- -| find_element.small.cairo | 735 | 106 | +| bitwise_builtin_test.starknet_with_keccak.cairo| 1293 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| is_positive.small.cairo | 1035 | 108 | +| alloc.cairo | 871 | 229 | --------------------------------------------------------------------------------------------------------------------------- -| reduce_v1.small.cairo | 892 | 107 | +| is_zero.small.cairo | 870 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| unsafe_keccak.small.cairo | 661 | 103 | +| signed_div_rem.small.cairo | 804 | 111 | --------------------------------------------------------------------------------------------------------------------------- -| assert_250_bits.small.cairo | 814 | 104 | +| simple.cairo | 606 | 103 | =========================================================================================================================== diff --git a/integration_tests/cairo_zero_hint_tests/blake.starknet_with_keccak.cairo b/integration_tests/cairo_zero_hint_tests/blake.starknet_with_keccak.cairo index 210053fe9..b93c7583e 100644 --- a/integration_tests/cairo_zero_hint_tests/blake.starknet_with_keccak.cairo +++ b/integration_tests/cairo_zero_hint_tests/blake.starknet_with_keccak.cairo @@ -3,8 +3,9 @@ %builtins range_check bitwise from starkware.cairo.common.alloc import alloc -from starkware.cairo.common.cairo_blake2s.blake2s import blake2s +from starkware.cairo.common.cairo_blake2s.blake2s import blake2s, blake2s_felts from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.bool import TRUE, FALSE func test_hash{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}() { alloc_locals; @@ -20,8 +21,47 @@ func test_hash{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}() { return (); } +func test_blake2s_felts{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}() { + alloc_locals; + let inputs: felt* = alloc(); + assert inputs[0] = 3456722; + assert inputs[1] = 435425528; + assert inputs[2] = 3232553; + assert inputs[3] = 2576195; + assert inputs[4] = 73471943; + assert inputs[5] = 17549868; + assert inputs[6] = 87158958; + assert inputs[7] = 6353668; + assert inputs[8] = 343656565; + assert inputs[9] = 1255962; + assert inputs[10] = 25439785; + assert inputs[11] = 1154578; + assert inputs[12] = 585849303; + assert inputs[13] = 763502; + assert inputs[14] = 43753647; + assert inputs[15] = 74256930; + let (local blake2s_ptr_start) = alloc(); + let blake2s_ptr = blake2s_ptr_start; + + // Bigendian + let (result) = blake2s_felts{range_check_ptr=range_check_ptr, blake2s_ptr=blake2s_ptr}( + 16, inputs, TRUE + ); + assert result.low = 23022179997536219430502258022509199703; + assert result.high = 136831746058902715979837770794974289597; + + // Little endian + let (result) = blake2s_felts{range_check_ptr=range_check_ptr, blake2s_ptr=blake2s_ptr}( + 16, inputs, FALSE + ); + assert result.low = 315510691254085211243916597439546947220; + assert result.high = 42237338665522721102428636006748876126; + return (); +} + func main{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}() { test_hash(); + test_blake2s_felts(); return (); } From 11f3f01c4957be32f7641df7d00f4cc876c460cb Mon Sep 17 00:00:00 2001 From: Harikrishnan Shaji Date: Sat, 6 Jul 2024 11:07:53 +0530 Subject: [PATCH 5/6] Fix checkUsedCells bug --- pkg/runners/zero/zero.go | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/pkg/runners/zero/zero.go b/pkg/runners/zero/zero.go index 098029693..909761dba 100644 --- a/pkg/runners/zero/zero.go +++ b/pkg/runners/zero/zero.go @@ -287,12 +287,17 @@ func (runner *ZeroRunner) EndRun() { // or there are not enough trace cells to fill the entire range check range func (runner *ZeroRunner) checkUsedCells() error { for _, bRunner := range runner.layout.Builtins { - builtinSegment, ok := runner.vm.Memory.FindSegmentWithBuiltin(bRunner.Runner.String()) + builtinName := bRunner.Runner.String() + builtinSegment, ok := runner.vm.Memory.FindSegmentWithBuiltin(builtinName) if ok { - _, err := bRunner.Runner.GetAllocatedSize(builtinSegment.Len(), runner.steps()) + segmentUsedSize := builtinSegment.Len() + allocatedSize, err := bRunner.Runner.GetAllocatedSize(segmentUsedSize, runner.steps()) if err != nil { return err } + if segmentUsedSize > allocatedSize { + return fmt.Errorf("builtin %s used size: %d exceeds allocated size: %d ", builtinName, segmentUsedSize, allocatedSize) + } } } return runner.checkRangeCheckUsage() From c696cda9a4076c46103e10cbdf819376c39798c0 Mon Sep 17 00:00:00 2001 From: Harikrishnan Shaji Date: Sat, 6 Jul 2024 11:15:14 +0530 Subject: [PATCH 6/6] Update blake test --- integration_tests/BenchMarks.txt | 94 +++++++++---------- .../blake.starknet_with_keccak.cairo | 59 +++++++++++- 2 files changed, 105 insertions(+), 48 deletions(-) diff --git a/integration_tests/BenchMarks.txt b/integration_tests/BenchMarks.txt index ce2f8a793..02062b71f 100644 --- a/integration_tests/BenchMarks.txt +++ b/integration_tests/BenchMarks.txt @@ -1,97 +1,97 @@ =========================================================================================================================== | File | PythonVM (ms) | GoVM (ms) | =========================================================================================================================== -| uint256_unsigned_div_rem.small.cairo | 872 | 106 | +| find_element.small.cairo | 730 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| unsafe_keccak_finalize.small.cairo | 659 | 103 | +| memcpy.cairo | 816 | 109 | --------------------------------------------------------------------------------------------------------------------------- -| keccak_test.starknet_with_keccak.cairo| 1304 | 107 | +| uint256_mul_div_mod.small.cairo | 1165 | 111 | --------------------------------------------------------------------------------------------------------------------------- -| assert_not_zero.cairo | 678 | 109 | +| cmp.small.cairo | 923 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| dict_squash.small.cairo | 1965 | 273 | +| ec.small.cairo | 4582 | 190 | --------------------------------------------------------------------------------------------------------------------------- -| split64.small.cairo | 944 | 107 | +| set_add.small.cairo | 688 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| split_felt.small.cairo | 890 | 104 | +| signed_div_rem.small.cairo | 756 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| cmp.small.cairo | 1150 | 111 | +| uint256_add.small.cairo | 818 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| memcpy.cairo | 615 | 105 | +| unsafe_keccak_finalize.small.cairo | 686 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| factorial.cairo | 1041 | 105 | +| alloc.cairo | 1009 | 243 | --------------------------------------------------------------------------------------------------------------------------- -| search_sorted_lower.small.cairo | 760 | 109 | +| blake.starknet_with_keccak.cairo | 48703 | 663 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_signedNN.small.cairo | 863 | 108 | +| reduce_v1.small.cairo | 1000 | 129 | --------------------------------------------------------------------------------------------------------------------------- -| fib.cairo | 666 | 103 | +| search_sorted_lower.small.cairo | 1068 | 112 | --------------------------------------------------------------------------------------------------------------------------- -| assert_250_bits.small.cairo | 915 | 129 | +| split_int.small.cairo | 774 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| ec.small.cairo | 5145 | 159 | +| pedersen_test.small.cairo | 685 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| get_point_from_x.small.cairo | 869 | 109 | +| assert_not_zero.cairo | 793 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| pow.small.cairo | 787 | 106 | +| dict.cairo | 630 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| assert_not_equal.cairo | 783 | 105 | +| div_mod_n.small.cairo | 1041 | 119 | --------------------------------------------------------------------------------------------------------------------------- -| hintrefs.cairo | 671 | 105 | +| is_quad_residue.small.cairo | 805 | 123 | --------------------------------------------------------------------------------------------------------------------------- -| import_secp256R1P.small.cairo | 697 | 106 | +| sqrt.small.cairo | 837 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| sqrt.small.cairo | 806 | 108 | +| unsigned_div_rem.small.cairo | 797 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| verify_ecdsa_signature.small.cairo | 937 | 108 | +| fib.cairo | 689 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| verify_zero.small.cairo | 801 | 105 | +| assert_not_equal.cairo | 1041 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| ecdsa_test.starknet_with_keccak.cairo | 1399 | 107 | +| hintrefs.cairo | 660 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| pedersen_test.small.cairo | 636 | 103 | +| is_positive.small.cairo | 773 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| blake.starknet_with_keccak.cairo | 3863 | 136 | +| split_felt.small.cairo | 1000 | 111 | --------------------------------------------------------------------------------------------------------------------------- -| reduce_v1.small.cairo | 823 | 105 | +| verify_ecdsa_signature.small.cairo | 802 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_add.small.cairo | 708 | 103 | +| simple.cairo | 659 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_sqrt.small.cairo | 929 | 108 | +| bitwise_builtin_test.starknet_with_keccak.cairo| 1324 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| poseidon_test.starknet_with_keccak.cairo| 1260 | 146 | +| verify_zero.small.cairo | 767 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| dict.cairo | 1876 | 109 | +| assert_250_bits.small.cairo | 1113 | 142 | --------------------------------------------------------------------------------------------------------------------------- -| is_positive.small.cairo | 754 | 107 | +| dict_squash.small.cairo | 825 | 117 | --------------------------------------------------------------------------------------------------------------------------- -| split_int.small.cairo | 803 | 105 | +| get_point_from_x.small.cairo | 933 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_mul_div_mod.small.cairo | 914 | 106 | +| import_secp256R1P.small.cairo | 647 | 110 | --------------------------------------------------------------------------------------------------------------------------- -| set_add.small.cairo | 690 | 107 | +| split64.small.cairo | 873 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| unsafe_keccak.small.cairo | 698 | 104 | +| uint256_unsigned_div_rem.small.cairo | 1071 | 112 | --------------------------------------------------------------------------------------------------------------------------- -| unsigned_div_rem.small.cairo | 819 | 105 | +| unsafe_keccak.small.cairo | 758 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| usort.small.cairo | 885 | 112 | +| factorial.cairo | 1206 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| div_mod_n.small.cairo | 1921 | 150 | +| keccak_test.starknet_with_keccak.cairo| 1357 | 112 | --------------------------------------------------------------------------------------------------------------------------- -| find_element.small.cairo | 889 | 106 | +| pow.small.cairo | 868 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| is_quad_residue.small.cairo | 862 | 124 | +| uint256_signedNN.small.cairo | 799 | 111 | --------------------------------------------------------------------------------------------------------------------------- -| memset.cairo | 853 | 179 | +| usort.small.cairo | 759 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| bitwise_builtin_test.starknet_with_keccak.cairo| 1293 | 108 | +| poseidon_test.starknet_with_keccak.cairo| 1350 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| alloc.cairo | 871 | 229 | +| is_zero.small.cairo | 978 | 112 | --------------------------------------------------------------------------------------------------------------------------- -| is_zero.small.cairo | 870 | 107 | +| memset.cairo | 825 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| signed_div_rem.small.cairo | 804 | 111 | +| uint256_sqrt.small.cairo | 1167 | 109 | --------------------------------------------------------------------------------------------------------------------------- -| simple.cairo | 606 | 103 | +| ecdsa_test.starknet_with_keccak.cairo | 1485 | 109 | =========================================================================================================================== diff --git a/integration_tests/cairo_zero_hint_tests/blake.starknet_with_keccak.cairo b/integration_tests/cairo_zero_hint_tests/blake.starknet_with_keccak.cairo index b93c7583e..8d900c6c6 100644 --- a/integration_tests/cairo_zero_hint_tests/blake.starknet_with_keccak.cairo +++ b/integration_tests/cairo_zero_hint_tests/blake.starknet_with_keccak.cairo @@ -3,9 +3,10 @@ %builtins range_check bitwise from starkware.cairo.common.alloc import alloc -from starkware.cairo.common.cairo_blake2s.blake2s import blake2s, blake2s_felts +from starkware.cairo.common.cairo_blake2s.blake2s import blake2s, blake2s_felts, finalize_blake2s from starkware.cairo.common.cairo_builtins import BitwiseBuiltin from starkware.cairo.common.bool import TRUE, FALSE +from starkware.cairo.common.uint256 import Uint256 func test_hash{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}() { alloc_locals; @@ -59,9 +60,65 @@ func test_blake2s_felts{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}() { return (); } +func fill_array(array: felt*, base: felt, step: felt, array_length: felt, iterator: felt) { + if (iterator == array_length) { + return (); + } + assert array[iterator] = base + step * iterator; + return fill_array(array, base, step, array_length, iterator + 1); +} + +func test_integration{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(iter: felt, last: felt) { + alloc_locals; + if (iter == last) { + return (); + } + + let (data: felt*) = alloc(); + fill_array(data, iter, 2 * iter, 10, 0); + + let (local blake2s_ptr_start) = alloc(); + let blake2s_ptr = blake2s_ptr_start; + let (res_1: Uint256) = blake2s{range_check_ptr=range_check_ptr, blake2s_ptr=blake2s_ptr}( + data, 9 + ); + + finalize_blake2s(blake2s_ptr_start, blake2s_ptr); + + let (local blake2s_ptr_start) = alloc(); + let blake2s_ptr = blake2s_ptr_start; + + let (data_2: felt*) = alloc(); + assert data_2[0] = res_1.low; + assert data_2[1] = res_1.high; + + let (res_2) = blake2s_felts{range_check_ptr=range_check_ptr, blake2s_ptr=blake2s_ptr}( + 2, data_2, TRUE + ); + + finalize_blake2s(blake2s_ptr_start, blake2s_ptr); + + if (iter == last - 1 and last == 10) { + assert res_1.low = 327684140823325841083166505949840946643; + assert res_1.high = 28077572547397067729112288485703133566; + assert res_2.low = 323710308182296053867309835081443411626; + assert res_2.high = 159988406782415793602959692147600111481; + } + + if (iter == last - 1 and last == 100) { + assert res_1.low = 26473789897582596397897414631405692327; + assert res_1.high = 35314462001555260569814614879256292984; + assert res_2.low = 256911263205530722270005922452382996929; + assert res_2.high = 248798531786594770765531047659644061441; + } + + return test_integration(iter + 1, last); +} + func main{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}() { test_hash(); test_blake2s_felts(); + test_integration(0, 10); return (); }