@matheusbsbs / matheus-bagliano / commits / 138ef8068c

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>

SZEDER Gábor committed Apr 20, 2023 at 22:53 UTC 138ef8068c54d72c9bd1b09753408fde7750ec86

3 files changed -170

contrib/coccinelle/tests/unused.c deleted

-82

@@ -1,82 +0,0 @@

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 -}

contrib/coccinelle/tests/unused.res deleted

-45

@@ -1,45 +0,0 @@

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 -}

contrib/coccinelle/unused.cocci deleted

-43

@@ -1,43 +0,0 @@

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 $