kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

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>
maint
SZEDER Gábor 2023-04-20 22:53:50 +02:00 committed by Junio C Hamano
parent 667fcf4e15
commit 138ef8068c
3 changed files with 0 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
contrib/coccinelle/tests/unused.c
View File

@ -1,82 +0,0 @@
void test_strbuf(void)
{
struct strbuf sb1 = STRBUF_INIT;
struct strbuf sb2 = STRBUF_INIT;
struct strbuf sb3 = STRBUF_INIT;
struct strbuf sb4 = STRBUF_INIT;
struct strbuf sb5;
struct strbuf sb6 = { 0 };
struct strbuf sb7 = STRBUF_INIT;
struct strbuf sb8 = STRBUF_INIT;
struct strbuf *sp1;
struct strbuf *sp2;
struct strbuf *sp3;
struct strbuf *sp4 = xmalloc(sizeof(struct strbuf));
struct strbuf *sp5 = xmalloc(sizeof(struct strbuf));
struct strbuf *sp6 = xmalloc(sizeof(struct strbuf));
struct strbuf *sp7;

strbuf_init(&sb5, 0);
strbuf_init(sp1, 0);
strbuf_init(sp2, 0);
strbuf_init(sp3, 0);
strbuf_init(sp4, 0);
strbuf_init(sp5, 0);
strbuf_init(sp6, 0);
strbuf_init(sp7, 0);
sp7 = xmalloc(sizeof(struct strbuf));

use_before(&sb3);
use_as_str("%s", sb7.buf);
use_as_str("%s", sp1->buf);
use_as_str("%s", sp6->buf);
pass_pp(&sp3);

strbuf_release(&sb1);
strbuf_reset(&sb2);
strbuf_release(&sb3);
strbuf_release(&sb4);
strbuf_release(&sb5);
strbuf_release(&sb6);
strbuf_release(&sb7);
strbuf_release(sp1);
strbuf_release(sp2);
strbuf_release(sp3);
strbuf_release(sp4);
strbuf_release(sp5);
strbuf_release(sp6);
strbuf_release(sp7);

use_after(&sb4);

if (when_strict())
return;
strbuf_release(&sb8);
}

void test_other(void)
{
struct string_list l = STRING_LIST_INIT_DUP;
struct strbuf sb = STRBUF_INIT;

string_list_clear(&l, 0);
string_list_clear(&sb, 0);
}

void test_worktrees(void)
{
struct worktree **w1 = get_worktrees();
struct worktree **w2 = get_worktrees();
struct worktree **w3;
struct worktree **w4;

w3 = get_worktrees();
w4 = get_worktrees();

use_it(w4);

free_worktrees(w1);
free_worktrees(w2);
free_worktrees(w3);
free_worktrees(w4);
}

45
contrib/coccinelle/tests/unused.res
View File

@ -1,45 +0,0 @@
void test_strbuf(void)
{
struct strbuf sb3 = STRBUF_INIT;
struct strbuf sb4 = STRBUF_INIT;
struct strbuf sb7 = STRBUF_INIT;
struct strbuf *sp1;
struct strbuf *sp3;
struct strbuf *sp6 = xmalloc(sizeof(struct strbuf));
strbuf_init(sp1, 0);
strbuf_init(sp3, 0);
strbuf_init(sp6, 0);

use_before(&sb3);
use_as_str("%s", sb7.buf);
use_as_str("%s", sp1->buf);
use_as_str("%s", sp6->buf);
pass_pp(&sp3);

strbuf_release(&sb3);
strbuf_release(&sb4);
strbuf_release(&sb7);
strbuf_release(sp1);
strbuf_release(sp3);
strbuf_release(sp6);

use_after(&sb4);

if (when_strict())
return;
}

void test_other(void)
{
}

void test_worktrees(void)
{
struct worktree **w4;

w4 = get_worktrees();

use_it(w4);

free_worktrees(w4);
}

43
contrib/coccinelle/unused.cocci
View File

@ -1,43 +0,0 @@
// This rule finds sequences of "unused" declerations and uses of a
// variable, where "unused" is defined to include only calling the
// equivalent of alloc, init & free functions on the variable.
@@
type T;
identifier I;
// STRBUF_INIT, but also e.g. STRING_LIST_INIT_DUP (so no anchoring)
constant INIT_MACRO =~ "_INIT";
identifier MALLOC1 =~ "^x?[mc]alloc$";
identifier INIT_ASSIGN1 =~ "^get_worktrees$";
identifier INIT_CALL1 =~ "^[a-z_]*_init$";
identifier REL1 =~ "^[a-z_]*_(release|reset|clear|free)$";
identifier REL2 =~ "^(release|clear|free)_[a-z_]*$";
@@

(
- T I;
|
- T I = { 0 };
|
- T I = INIT_MACRO;
|
- T I = MALLOC1(...);
|
- T I = INIT_ASSIGN1(...);
)

<... when != \( I \| &I \)
(
- \( INIT_CALL1 \)( \( I \| &I \), ...);
|
- I = \( INIT_ASSIGN1 \)(...);
|
- I = MALLOC1(...);
)
...>

(
- \( REL1 \| REL2 \)( \( I \| &I \), ...);
|
- \( REL1 \| REL2 \)( \( &I \| I \) );
)
... when != \( I \| &I \)