freshlybakedca.ke / git
Git fork
fork atom

cocci: remove 'unused.cocci'

When 'unused.cocci' was added in 4f40f6cb73 (cocci: add and apply a
rule to find "unused" strbufs, 2022-07-05) it found three unused
strbufs, and when it was generalized in the next commit it managed to
find an unused string_list as well. That's four unused variables in
over 17 years, so apparently we rarely make this mistake.

Unfortunately, applying 'unused.cocci' is quite expensive, e.g. it
increases the from-scratch runtime of 'make coccicheck' by over 5:30
minutes or over 160%:

$ make -s cocciclean
$ time make -s coccicheck
* new spatch flags

real 8m56.201s
user 0m0.420s
sys 0m0.406s
$ rm contrib/coccinelle/unused.cocci contrib/coccinelle/tests/unused.*
$ make -s cocciclean
$ time make -s coccicheck
* new spatch flags

real 3m23.893s
user 0m0.228s
sys 0m0.247s

That's a lot of runtime spent for not much in return, and arguably an
unused struct instance sneaking in is not that big of a deal to
justify the significantly increased runtime.

Remove 'unused.cocci', because we are not getting our CPU cycles'
worth.

Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

authored by

SZEDER Gábor and committed by
Junio C Hamano 138ef806 667fcf4e

-170
-82
contrib/coccinelle/tests/unused.c
··· 1 - void test_strbuf(void) 2 - { 3 - struct strbuf sb1 = STRBUF_INIT; 4 - struct strbuf sb2 = STRBUF_INIT; 5 - struct strbuf sb3 = STRBUF_INIT; 6 - struct strbuf sb4 = STRBUF_INIT; 7 - struct strbuf sb5; 8 - struct strbuf sb6 = { 0 }; 9 - struct strbuf sb7 = STRBUF_INIT; 10 - struct strbuf sb8 = STRBUF_INIT; 11 - struct strbuf *sp1; 12 - struct strbuf *sp2; 13 - struct strbuf *sp3; 14 - struct strbuf *sp4 = xmalloc(sizeof(struct strbuf)); 15 - struct strbuf *sp5 = xmalloc(sizeof(struct strbuf)); 16 - struct strbuf *sp6 = xmalloc(sizeof(struct strbuf)); 17 - struct strbuf *sp7; 18 - 19 - strbuf_init(&sb5, 0); 20 - strbuf_init(sp1, 0); 21 - strbuf_init(sp2, 0); 22 - strbuf_init(sp3, 0); 23 - strbuf_init(sp4, 0); 24 - strbuf_init(sp5, 0); 25 - strbuf_init(sp6, 0); 26 - strbuf_init(sp7, 0); 27 - sp7 = xmalloc(sizeof(struct strbuf)); 28 - 29 - use_before(&sb3); 30 - use_as_str("%s", sb7.buf); 31 - use_as_str("%s", sp1->buf); 32 - use_as_str("%s", sp6->buf); 33 - pass_pp(&sp3); 34 - 35 - strbuf_release(&sb1); 36 - strbuf_reset(&sb2); 37 - strbuf_release(&sb3); 38 - strbuf_release(&sb4); 39 - strbuf_release(&sb5); 40 - strbuf_release(&sb6); 41 - strbuf_release(&sb7); 42 - strbuf_release(sp1); 43 - strbuf_release(sp2); 44 - strbuf_release(sp3); 45 - strbuf_release(sp4); 46 - strbuf_release(sp5); 47 - strbuf_release(sp6); 48 - strbuf_release(sp7); 49 - 50 - use_after(&sb4); 51 - 52 - if (when_strict()) 53 - return; 54 - strbuf_release(&sb8); 55 - } 56 - 57 - void test_other(void) 58 - { 59 - struct string_list l = STRING_LIST_INIT_DUP; 60 - struct strbuf sb = STRBUF_INIT; 61 - 62 - string_list_clear(&l, 0); 63 - string_list_clear(&sb, 0); 64 - } 65 - 66 - void test_worktrees(void) 67 - { 68 - struct worktree **w1 = get_worktrees(); 69 - struct worktree **w2 = get_worktrees(); 70 - struct worktree **w3; 71 - struct worktree **w4; 72 - 73 - w3 = get_worktrees(); 74 - w4 = get_worktrees(); 75 - 76 - use_it(w4); 77 - 78 - free_worktrees(w1); 79 - free_worktrees(w2); 80 - free_worktrees(w3); 81 - free_worktrees(w4); 82 - }
-45
contrib/coccinelle/tests/unused.res
··· 1 - void test_strbuf(void) 2 - { 3 - struct strbuf sb3 = STRBUF_INIT; 4 - struct strbuf sb4 = STRBUF_INIT; 5 - struct strbuf sb7 = STRBUF_INIT; 6 - struct strbuf *sp1; 7 - struct strbuf *sp3; 8 - struct strbuf *sp6 = xmalloc(sizeof(struct strbuf)); 9 - strbuf_init(sp1, 0); 10 - strbuf_init(sp3, 0); 11 - strbuf_init(sp6, 0); 12 - 13 - use_before(&sb3); 14 - use_as_str("%s", sb7.buf); 15 - use_as_str("%s", sp1->buf); 16 - use_as_str("%s", sp6->buf); 17 - pass_pp(&sp3); 18 - 19 - strbuf_release(&sb3); 20 - strbuf_release(&sb4); 21 - strbuf_release(&sb7); 22 - strbuf_release(sp1); 23 - strbuf_release(sp3); 24 - strbuf_release(sp6); 25 - 26 - use_after(&sb4); 27 - 28 - if (when_strict()) 29 - return; 30 - } 31 - 32 - void test_other(void) 33 - { 34 - } 35 - 36 - void test_worktrees(void) 37 - { 38 - struct worktree **w4; 39 - 40 - w4 = get_worktrees(); 41 - 42 - use_it(w4); 43 - 44 - free_worktrees(w4); 45 - }
-43
contrib/coccinelle/unused.cocci
··· 1 - // This rule finds sequences of "unused" declerations and uses of a 2 - // variable, where "unused" is defined to include only calling the 3 - // equivalent of alloc, init & free functions on the variable. 4 - @@ 5 - type T; 6 - identifier I; 7 - // STRBUF_INIT, but also e.g. STRING_LIST_INIT_DUP (so no anchoring) 8 - constant INIT_MACRO =~ "_INIT"; 9 - identifier MALLOC1 =~ "^x?[mc]alloc$"; 10 - identifier INIT_ASSIGN1 =~ "^get_worktrees$"; 11 - identifier INIT_CALL1 =~ "^[a-z_]*_init$"; 12 - identifier REL1 =~ "^[a-z_]*_(release|reset|clear|free)$"; 13 - identifier REL2 =~ "^(release|clear|free)_[a-z_]*$"; 14 - @@ 15 - 16 - ( 17 - - T I; 18 - | 19 - - T I = { 0 }; 20 - | 21 - - T I = INIT_MACRO; 22 - | 23 - - T I = MALLOC1(...); 24 - | 25 - - T I = INIT_ASSIGN1(...); 26 - ) 27 - 28 - <... when != \( I \| &I \) 29 - ( 30 - - \( INIT_CALL1 \)( \( I \| &I \), ...); 31 - | 32 - - I = \( INIT_ASSIGN1 \)(...); 33 - | 34 - - I = MALLOC1(...); 35 - ) 36 - ...> 37 - 38 - ( 39 - - \( REL1 \| REL2 \)( \( I \| &I \), ...); 40 - | 41 - - \( REL1 \| REL2 \)( \( &I \| I \) ); 42 - ) 43 - ... when != \( I \| &I \)