| FazBrowse GitHub Viewer | Trending | | Home |
| Tools: [Download Repo ZIP] [Original HTTPS Page] |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -10,8 +10,8 @@ | |||
| 10 | 10 | // Turn this on to include the y-position of the top box in the output. | |
| 11 | 11 | #define DEBUG 0 | |
| 12 | 12 | ||
| 13 | - #define WARMUP 64 | ||
| 14 | - #define FRAMES 333 | ||
| 13 | + int WARMUP; | ||
| 14 | + int FRAMES; | ||
| 15 | 15 | ||
| 16 | 16 | typedef struct { | |
| 17 | 17 | float mean; | |
@@ -52,7 +52,16 @@ result_t measure(clock_t times[FRAMES]) { | |||
| 52 | 52 | return r; | |
| 53 | 53 | } | |
| 54 | 54 | ||
| 55 | - int main() { | ||
| 55 | + int main(int argc, char **argv) { | ||
| 56 | + int arg = argc > 1 ? argv[1][0] - '0' : 1; | ||
| 57 | + switch(arg) { | ||
| 58 | + case 0: WARMUP = 32; FRAMES = 161; break; | ||
| 59 | + case 1: WARMUP = 64; FRAMES = 333; break; | ||
| 60 | + case 2: WARMUP = 5*64; FRAMES = 7*333; break; | ||
| 61 | + case 3: WARMUP = 10*64; FRAMES = 17*333; break; | ||
| 62 | + default: printf("error: %d\\n", arg); return -1; | ||
| 63 | + } | ||
| 64 | + | ||
| 56 | 65 | // Define the gravity vector. | |
| 57 | 66 | b2Vec2 gravity(0.0f, -10.0f); | |
| 58 | 67 | ||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -27,12 +27,20 @@ subject to the following restrictions: | |||
| 27 | 27 | ||
| 28 | 28 | ||
| 29 | 29 | #define NUM_DEMOS 7 | |
| 30 | - #define NUM_TESTS 200 | ||
| 31 | 30 | ||
| 32 | 31 | extern bool gDisableDeactivation; | |
| 33 | 32 | ||
| 34 | - int main(int argc,char** argv) | ||
| 35 | - { | ||
| 33 | + int main(int argc, char **argv) { | ||
| 34 | + int NUM_TESTS; | ||
| 35 | + int arg = argc > 1 ? argv[1][0] - '0' : 1; | ||
| 36 | + switch(arg) { | ||
| 37 | + case 0: NUM_TESTS = 7; break; | ||
| 38 | + case 1: NUM_TESTS = 33; break; | ||
| 39 | + case 2: NUM_TESTS = 5*33; break; | ||
| 40 | + case 3: NUM_TESTS = 7*35; break; | ||
| 41 | + default: printf("error: %d\\n", arg); return -1; | ||
| 42 | + } | ||
| 43 | + | ||
| 36 | 44 | gDisableDeactivation = true; | |
| 37 | 45 | ||
| 38 | 46 | BenchmarkDemo1 benchmarkDemo1; | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -145,9 +145,9 @@ fannkuch(int n) | |||
| 145 | 145 | } | |
| 146 | 146 | ||
| 147 | 147 | int | |
| 148 | - main(int ac, char **av) | ||
| 148 | + main(int argc, char **argv) | ||
| 149 | 149 | { | |
| 150 | - int n = ac > 1 ? atoi(av[1]) : 0; | ||
| 150 | + int n = argc > 1 ? atoi(argv[1]) : 0; | ||
| 151 | 151 | ||
| 152 | 152 | if (n < 1) { | |
| 153 | 153 | printf("Wrong argument.\n"); | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -74,14 +74,19 @@ void game(int w, int h, int i) | |||
| 74 | 74 | show(univ, w, h); | |
| 75 | 75 | } | |
| 76 | 76 | ||
| 77 | - int main(int c, char **v) | ||
| 77 | + int main(int argc, char **argv) | ||
| 78 | 78 | { | |
| 79 | - int w = 0, h = 0, i = -1; // i = -1 means run forever, normal. otherwise, run in benchmark mode | ||
| 80 | - if (c > 1) w = atoi(v[1]); | ||
| 81 | - if (c > 2) h = atoi(v[2]); | ||
| 82 | - if (c > 3) i = atoi(v[3]); | ||
| 83 | - if (w <= 0) w = 32; | ||
| 84 | - if (h <= 0) h = 32; | ||
| 79 | + int w, h, i; | ||
| 80 | + int arg = argc > 1 ? argv[1][0] - '0' : 1; | ||
| 81 | + switch(arg) { | ||
| 82 | + case 0: w = h = 32; i = 13000; break; | ||
| 83 | + case 1: w = h = 32; i = 24000; break; | ||
| 84 | + case 2: w = h = 32; i = 5*24000; break; | ||
| 85 | + case 3: w = h = 32; i = 10*24000; break; | ||
| 86 | + default: printf("error: %d\\n", arg); return -1; | ||
| 87 | + } | ||
| 88 | + | ||
| 89 | + printf("life: %d,%d,%d,%d\n", arg, w, h, i); | ||
| 85 | 90 | game(w, h, i); | |
| 86 | 91 | } | |
| 87 | 92 | ||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -12389,12 +12389,21 @@ def do_benchmark(self, name, src, args=[], expected_output='FAIL', emcc_args=[], | |||
| 12389 | 12389 | # self.print_stats(total_times, total_native_times, last=True) | |
| 12390 | 12390 | ||
| 12391 | 12391 | def test_primes(self): | |
| 12392 | - src = ''' | ||
| 12392 | + src = r''' | ||
| 12393 | 12393 | #include<stdio.h> | |
| 12394 | 12394 | #include<math.h> | |
| 12395 | - int main() { | ||
| 12395 | + int main(int argc, char **argv) { | ||
| 12396 | + int arg = argc > 1 ? argv[1][0] - '0' : 1; | ||
| 12397 | + switch(arg) { | ||
| 12398 | + case 0: arg = 130000; break; | ||
| 12399 | + case 1: arg = 220000; break; | ||
| 12400 | + case 2: arg = 610000; break; | ||
| 12401 | + case 3: arg = 1010000; break; | ||
| 12402 | + default: printf("error: %d\\n", arg); return -1; | ||
| 12403 | + } | ||
| 12404 | + | ||
| 12396 | 12405 | int primes = 0, curri = 2; | |
| 12397 | - while (primes < 220000) { | ||
| 12406 | + while (primes < arg) { | ||
| 12398 | 12407 | int ok = true; | |
| 12399 | 12408 | for (int j = 2; j < sqrtf(curri); j++) { | |
| 12400 | 12409 | if (curri % j == 0) { | |
@@ -12407,7 +12416,7 @@ def test_primes(self): | |||
| 12407 | 12416 | } | |
| 12408 | 12417 | curri++; | |
| 12409 | 12418 | } | |
| 12410 | - printf("lastprime: %d.\\n", curri-1); | ||
| 12419 | + printf("lastprime: %d.\n", curri-1); | ||
| 12411 | 12420 | return 0; | |
| 12412 | 12421 | } | |
| 12413 | 12422 | ''' | |
@@ -12418,9 +12427,17 @@ def test_memops(self): | |||
| 12418 | 12427 | #include<stdio.h> | |
| 12419 | 12428 | #include<string.h> | |
| 12420 | 12429 | #include<stdlib.h> | |
| 12421 | - int main() { | ||
| 12422 | - int N = 1024*1024; | ||
| 12423 | - int M = 800; | ||
| 12430 | + int main(int argc, char **argv) { | ||
| 12431 | + int N, M; | ||
| 12432 | + int arg = argc > 1 ? argv[1][0] - '0' : 1; | ||
| 12433 | + switch(arg) { | ||
| 12434 | + case 0: N = 1024*1024; M = 400; break; | ||
| 12435 | + case 1: N = 1024*1024; M = 800; break; | ||
| 12436 | + case 2: N = 1024*1024; M = 4000; break; | ||
| 12437 | + case 3: N = 1024*1024; M = 8000; break; | ||
| 12438 | + default: printf("error: %d\\n", arg); return -1; | ||
| 12439 | + } | ||
| 12440 | + | ||
| 12424 | 12441 | int final = 0; | |
| 12425 | 12442 | char *buf = (char*)malloc(N); | |
| 12426 | 12443 | for (int t = 0; t < M; t++) { | |
@@ -12499,9 +12516,18 @@ def test_copy(self): | |||
| 12499 | 12516 | } | |
| 12500 | 12517 | int sum() { return x + y + z + r + g + b; } | |
| 12501 | 12518 | }; | |
| 12502 | - int main() { | ||
| 12519 | + int main(int argc, char **argv) { | ||
| 12520 | + int arg = argc > 1 ? argv[1][0] - '0' : 1; | ||
| 12521 | + switch(arg) { | ||
| 12522 | + case 0: arg = 625; break; | ||
| 12523 | + case 1: arg = 1250; break; | ||
| 12524 | + case 2: arg = 5*1250; break; | ||
| 12525 | + case 3: arg = 10*1250; break; | ||
| 12526 | + default: printf("error: %d\\n", arg); return -1; | ||
| 12527 | + } | ||
| 12528 | + | ||
| 12503 | 12529 | int total = 0; | |
| 12504 | - for (int i = 0; i < 1250; i++) { | ||
| 12530 | + for (int i = 0; i < arg; i++) { | ||
| 12505 | 12531 | for (int j = 0; j < 50000; j++) { | |
| 12506 | 12532 | vec c(i, i+i%10, j*2, i%255, j%120, i%15); | |
| 12507 | 12533 | vec d(j+i%10, j*2, j%255, i%120, j%15, j); | |
@@ -12520,19 +12546,41 @@ def test_copy(self): | |||
| 12520 | 12546 | return 0; | |
| 12521 | 12547 | } | |
| 12522 | 12548 | ''' | |
| 12523 | - self.do_benchmark('copy', src, [], 'sum:2836\n', emcc_args=['-s', 'QUANTUM_SIZE=4', '-s', 'USE_TYPED_ARRAYS=2']) | ||
| 12549 | + self.do_benchmark('copy', src, [], 'sum:2836\n') | ||
| 12524 | 12550 | ||
| 12525 | 12551 | def test_fannkuch(self): | |
| 12526 | - src = open(path_from_root('tests', 'fannkuch.cpp'), 'r').read() | ||
| 12552 | + src = open(path_from_root('tests', 'fannkuch.cpp'), 'r').read().replace( | ||
| 12553 | + 'int n = argc > 1 ? atoi(argv[1]) : 0;', | ||
| 12554 | + ''' | ||
| 12555 | + int n; | ||
| 12556 | + int arg = argc > 1 ? argv[1][0] - '0' : 1; | ||
| 12557 | + switch(arg) { | ||
| 12558 | + case 0: n = 10; break; | ||
| 12559 | + case 1: n = 11; break; | ||
| 12560 | + case 2: n = 11; break; | ||
| 12561 | + case 3: n = 12; break; | ||
| 12562 | + default: printf("error: %d\\n", arg); return -1; | ||
| 12563 | + } | ||
| 12564 | + ''' | ||
| 12565 | + ) | ||
| 12566 | + assert 'switch(arg)' in src | ||
| 12527 | 12567 | self.do_benchmark('fannkuch', src, ['11'], 'Pfannkuchen(11) = 51.') | |
| 12528 | 12568 | ||
| 12529 | 12569 | def test_corrections(self): | |
| 12530 | 12570 | src = r''' | |
| 12531 | 12571 | #include<stdio.h> | |
| 12532 | 12572 | #include<math.h> | |
| 12533 | - int main() { | ||
| 12534 | - int N = 20000; | ||
| 12535 | - int M = 7000; | ||
| 12573 | + int main(int argc, char **argv) { | ||
| 12574 | + int N, M; | ||
| 12575 | + int arg = argc > 1 ? argv[1][0] - '0' : 1; | ||
| 12576 | + switch(arg) { | ||
| 12577 | + case 0: N = 20000; M = 3500; break; | ||
| 12578 | + case 1: N = 20000; M = 7000; break; | ||
| 12579 | + case 2: N = 20000; M = 5*7000; break; | ||
| 12580 | + case 3: N = 20000; M = 10*7000; break; | ||
| 12581 | + default: printf("error: %d\\n", arg); return -1; | ||
| 12582 | + } | ||
| 12583 | + | ||
| 12536 | 12584 | unsigned int f = 0; | |
| 12537 | 12585 | unsigned short s = 0; | |
| 12538 | 12586 | for (int t = 0; t < M; t++) { | |
@@ -12551,7 +12599,19 @@ def test_corrections(self): | |||
| 12551 | 12599 | ||
| 12552 | 12600 | def fasta(self, double_rep): | |
| 12553 | 12601 | src = open(path_from_root('tests', 'fasta.cpp'), 'r').read().replace('double', double_rep) | |
| 12554 | - self.do_benchmark('fasta', src, ['19000000'], '''GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA\nTCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT\nAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG\nGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG\nCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT\nGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA\nGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA\nTTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG\nAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA\nGCCTGGGCGA''') | ||
| 12602 | + src = src.replace(' const size_t n = ( argc > 1 ) ? atoi( argv[1] ) : 512;', ''' | ||
| 12603 | + int n; | ||
| 12604 | + int arg = argc > 1 ? argv[1][0] - '0' : 1; | ||
| 12605 | + switch(arg) { | ||
| 12606 | + case 0: n = 19000000/2; break; | ||
| 12607 | + case 1: n = 19000000; break; | ||
| 12608 | + case 2: n = 19000000*5; break; | ||
| 12609 | + case 3: n = 19000000*10; break; | ||
| 12610 | + default: printf("error: %d\\n", arg); return -1; | ||
| 12611 | + } | ||
| 12612 | + ''') | ||
| 12613 | + assert 'switch(arg)' in src | ||
| 12614 | + self.do_benchmark('fasta', src, [], '''GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA\nTCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT\nAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG\nGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG\nCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT\nGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA\nGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA\nTTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG\nAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA\nGCCTGGGCGA''') | ||
| 12555 | 12615 | ||
| 12556 | 12616 | def test_fasta_float(self): | |
| 12557 | 12617 | self.fasta('float') | |
@@ -12561,53 +12621,52 @@ def zzztest_fasta_double(self): | |||
| 12561 | 12621 | ||
| 12562 | 12622 | def test_skinning(self): | |
| 12563 | 12623 | src = open(path_from_root('tests', 'skinning_test_no_simd.cpp'), 'r').read() | |
| 12564 | - self.do_benchmark('skinning', src, ['9500', '10000'], 'blah=0.000000') | ||
| 12624 | + self.do_benchmark('skinning', src, [], 'blah=0.000000') | ||
| 12565 | 12625 | ||
| 12566 | 12626 | def test_life(self): | |
| 12567 | 12627 | src = open(path_from_root('tests', 'life.c'), 'r').read() | |
| 12568 | - self.do_benchmark('life', src, ['32', '32', '15000'], '''-------------------------------- | ||
| 12569 | - [] [][][] [] [] [][] | ||
| 12570 | - [] [][] [] [] [] [] | ||
| 12571 | - [] [][] [][] [] | ||
| 12572 | - [] [] [] [] | ||
| 12573 | - [] [] [] [] [] [] [] [] | ||
| 12574 | - [][][][] [] [][] [][] | ||
| 12575 | - [] | ||
| 12576 | - [] | ||
| 12577 | - [] [] | ||
| 12578 | - [][] [] [] | ||
| 12579 | - [][] [][][] | ||
| 12580 | - [] | ||
| 12581 | - | ||
| 12582 | - [] | ||
| 12583 | - [] [] | ||
| 12584 | - [][] | ||
| 12585 | - [] [] [][] [][] | ||
| 12586 | - [] [] [] [] | ||
| 12587 | - [][] [] | ||
| 12588 | - [][][][] | ||
| 12589 | - | ||
| 12590 | - [][][] [][] | ||
| 12591 | - [][][] [][] | ||
| 12592 | - [] | ||
| 12593 | - [] | ||
| 12594 | - [] [][][] [] | ||
| 12595 | - [] [] | ||
| 12596 | - [][] [] | ||
| 12597 | - [][][] | ||
| 12598 | - [][][] [][] | ||
| 12599 | - [][][][][] [] [][] | ||
| 12600 | - [] [][] [] [] | ||
| 12601 | - -------------------------------- | ||
| 12602 | - ''', shared_args=['-std=c99'], force_c=True) | ||
| 12628 | + self.do_benchmark('life', src, [], '''-------------------------------- | ||
| 12629 | + [][] [] [] | ||
| 12630 | + [][] [][] [] [] | ||
| 12631 | + [][] [] [] | ||
| 12632 | + [][] [] [] | ||
| 12633 | + [] [][] [] | ||
| 12634 | + [][] [] [] [] [] | ||
| 12635 | + [][] [] [] [] [] | ||
| 12636 | + [] [][] [] | ||
| 12637 | + [][] [][] | ||
| 12638 | + [][] [][] [] [] | ||
| 12639 | + [][] [][] [][] [] | ||
| 12640 | + [][] [] | ||
| 12641 | + [] | ||
| 12642 | + [] | ||
| 12643 | + [] [] | ||
| 12644 | + [] [][][] [] [] | ||
| 12645 | + [] [][][][][][] [] [][] | ||
| 12646 | + [] [][] [] [] [][] [] [] | ||
| 12647 | + [] [] [][] [] [] | ||
| 12648 | + [][] [] [][][] [][] | ||
| 12649 | + [] [] [][][] | ||
| 12650 | + [][] [][][][] | ||
| 12651 | + [][] [][] [] | ||
| 12652 | + [] [][] [] | ||
| 12653 | + [][] | ||
| 12654 | + [][] [] | ||
| 12655 | + [] [][][][][] | ||
| 12656 | + [][][] [][] | ||
| 12657 | + [][] [] [][][] | ||
| 12658 | + [] [] [][] | ||
| 12659 | + [] | ||
| 12660 | + [] [][] [][][] | ||
| 12661 | + --------------------------------''', shared_args=['-std=c99'], force_c=True) | ||
| 12603 | 12662 | ||
| 12604 | 12663 | def test_zlib(self): | |
| 12605 | 12664 | src = open(path_from_root('tests', 'zlib', 'benchmark.c'), 'r').read() | |
| 12606 | 12665 | emcc_args = self.get_library('zlib', os.path.join('libz.a'), make_args=['libz.a']) + \ | |
| 12607 | 12666 | ['-I' + path_from_root('tests', 'zlib')] | |
| 12608 | 12667 | native_args = self.get_library('zlib_native', os.path.join('libz.a'), make_args=['libz.a'], native=True) + \ | |
| 12609 | 12668 | ['-I' + path_from_root('tests', 'zlib')] | |
| 12610 | - self.do_benchmark('zlib', src, ['100000', '500'], '''sizes: 100000,25906 | ||
| 12669 | + self.do_benchmark('zlib', src, [], '''sizes: 100000,25906 | ||
| 12611 | 12670 | ok. | |
| 12612 | 12671 | ''', | |
| 12613 | 12672 | force_c=True, emcc_args=emcc_args, native_args=native_args) | |
@@ -12643,7 +12702,7 @@ def test_zzz_bullet(self): # Called thus so it runs late in the alphabetical cyc | |||
| 12643 | 12702 | native_args = native_lib + ['-I' + path_from_root('tests', 'bullet', 'src'), | |
| 12644 | 12703 | '-I' + path_from_root('tests', 'bullet', 'Demos', 'Benchmarks')] | |
| 12645 | 12704 | ||
| 12646 | - self.do_benchmark('bullet', src, [], '\nok.\n', emcc_args=emcc_args, native_args=native_args, reps=1) | ||
| 12705 | + self.do_benchmark('bullet', src, [], '\nok.\n', emcc_args=emcc_args, native_args=native_args) | ||
| 12647 | 12706 | ||
| 12648 | 12707 | elif 'sanity' in str(sys.argv): | |
| 12649 | 12708 | ||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -171,8 +171,15 @@ void calculateVerticesAndNormals_x87( | |||
| 171 | 171 | ||
| 172 | 172 | int main (int argc, char*argv[]) | |
| 173 | 173 | { | |
| 174 | - const int N=atoi(argv[1]); | ||
| 175 | - const int M=atoi(argv[2]); | ||
| 174 | + int N, M; | ||
| 175 | + int arg = argc > 1 ? argv[1][0] - '0' : 1; | ||
| 176 | + switch(arg) { | ||
| 177 | + case 0: N = 6600; M = 6500; break; | ||
| 178 | + case 1: N = 9500; M = 10000; break; | ||
| 179 | + case 2: N = 2*11000; M = 2*12000; break; | ||
| 180 | + case 3: N = 3*10000; M = 3*10800; break; | ||
| 181 | + default: printf("error: %d\\n", arg); return -1; | ||
| 182 | + } | ||
| 176 | 183 | ||
| 177 | 184 | Vertex *v = new Vertex[N]; | |
| 178 | 185 | Influence *i = new Influence[N]; | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -26,8 +26,16 @@ void __attribute__ ((noinline)) doit(char *buffer, int size, int i) { | |||
| 26 | 26 | } | |
| 27 | 27 | ||
| 28 | 28 | int main(int argc, char **argv) { | |
| 29 | - int size = atoi(argv[1]); | ||
| 30 | - int iters = atoi(argv[2]); | ||
| 29 | + int size, iters; | ||
| 30 | + int arg = argc > 1 ? argv[1][0] - '0' : 1; | ||
| 31 | + switch(arg) { | ||
| 32 | + case 0: size = 100000; iters = 250; break; | ||
| 33 | + case 1: size = 100000; iters = 500; break; | ||
| 34 | + case 2: size = 100000; iters = 5*500; break; | ||
| 35 | + case 3: size = 100000; iters = 10*500; break; | ||
| 36 | + default: printf("error: %d\\n", arg); return -1; | ||
| 37 | + } | ||
| 38 | + | ||
| 31 | 39 | char *buffer = malloc(size); | |
| 32 | 40 | ||
| 33 | 41 | int i = 0; | |
| Back | FazBrowse Home | New Git URL |
0 commit comments