1 / 54

A Mutation / Injection-based Automatic Framework for Evaluating Code Clone Detection Tools

A Mutation / Injection-based Automatic Framework for Evaluating Code Clone Detection Tools. Chanchal Roy University of Saskatchewan The 9th CREST Open Workshop Code Provenance and clone Detection Nov 23, 2010. Clone Class. Introduction. What are “Code Clones”?

gyda
Download Presentation

A Mutation / Injection-based Automatic Framework for Evaluating Code Clone Detection Tools

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. A Mutation / Injection-based Automatic Framework for Evaluating Code Clone Detection Tools Chanchal Roy University of Saskatchewan The 9th CREST Open Workshop Code Provenance and clone Detection Nov 23, 2010

  2. Clone Class Introduction • What are “Code Clones”? • A code fragment which has identical or similar code fragment (s) in source code Clone Pair

  3. Introduction • Intentional copy/paste is a common reuse technique in software development • Previous studies report 7% - 30% cloned code software systems [Baker WCRE’95, Roy and Cordy WCRE’08] • Unfortunately, clones are harmful in software maintenance and evolution [Juergens et al. ICSE’09]

  4. Introduction: Existing Methods • In response, many methods proposed: • Text-based: Duploc[Ducasse et al. ICSM’99], NICAD[Roy and Cordy, ICPC’08] • Token-based: Dup[Baker, WCRE’95],CCFinder[Kamiya et al., TSE’02], CP-Miner [Li et al., TSE’06] • Tree-Based: CloneDr[Baxter et al. ICSM’98], Asta[Evans et al. WCRE’07], Deckard[Jiang et al. ICSE’07],cpdetector[Falke et al. ESE’08] • Metrics-based: KontogiannisWCRE’97,Mayrand et al. ICSM’96 • Graph-based: Gabelet al. ICSE’08, Komondoorand HorwitzSAS’01,Dublix[Krinke WCRE’01]

  5. Introduction: Lack of Evaluation • Marked lack of in-depth evaluation of the methods in terms of • precision and • recall • Existing tool comparison experiments (e.g., Bellon et al. TSE’07) or individual evaluations have faced serious challenges [Baker TSE’07, Roy and Cordy ICPC’08, SCP’09]

  6. | D | | D | Precision = Recall= | C | | A | Introduction: Precision and Recall Software System A: Actual clones? C: Candidate clones detected by T D: Detected actual clones False negatives False positives

  7. Primary Challenge:Lack of a Reliable Reference Set Software System A :Actual clones? C : Candidate clones. We DON’T have this We still don’t have this actual/reliable clone set for any system

  8. Challenges in Oracling a System • No crisp definition of code clones • Huge manual effort • May be possible for small system • What about for large systems? • Even the relatively small cook system yields nearly a million function pairs to sort through • Not possible for human to do error-free

  9. Challenges in Evaluation • Union of results from different tools can give good relative results • but no guarantee that the subject tools indeed detect all the clones • Manual validation of the large candidate clone set is difficult • Bellon [TSE’07] took 77 hours for only 2% of clones • No studies report the reliability of judges

  10. Lack of Evaluation for Individual Types of Clones • No work reports precision and recall values for different types of clones except, • Bellon et al. [TSE’07]: Types I, II and III • Falke et al. [ESE’08]: Types I and II • Limitations reported • Baker [TSE’07] • Roy and Cordy ICPC’08, Roy et al. SCP’09

  11. In this talk… • A mutation-based framework that automatically and efficiently • measures and • compares precision and recall of the tools fordifferent fine-grained types of clones. • A taxonomy of clones • => Mutation operators for cloning • => Framework for tool comparison

  12. An Editing Taxonomy of Clones • Definition of clone is inherently vague • Most cases detection dependent and task-oriented • Some taxonomies proposed • but limited to function clones and still contain the vague terms, “similar” and “long differences” [Roy and Cordy SCP’09, ICPC’08] • We derived the taxonomy from the literature and validated with empirical studies [Roy and Cordy WCRE’08] • Applicable to any granularity of clones

  13. void sumProd(int n) { //s0 int sum=0; //s1 int product =1; //s2 for (int i=1; i<=n; i++) { //s3 sum=sum + i; //s4 product = product * i; //s5 fun(sum, product); }} //s6 Exact Software Clones Changes in layout and formatting void sumProd(int n) { //s0 int sum=0; //s1 int product =1; //s2 for (int i=1; i<=n; i++) { //s3 sum=sum + i; //s4 product = product * i; //s5 fun(sum, product); }} //s6 Type I Reuse by copy and paste Changes in whitespace Changes in comments Changes in formatting void sumProd(int n) { //s0 int sum=0; //s1’ int product =1; //s2 for (int i=1; i<=n; i++) { //s3’ sum=sum + i; //s4 product = product * i; //s5’ fun(sum, product); }} //s6 void sumProd(int n) { //s0 int sum=0; //s1 int product =1; //s2 for (int i=1; i<=n; i++) //s3 sum=sum + i; //s4 product = product * i; //s5 fun(sum, product); }} //s6 void sumProd(int n) { //s0 int sum=0; //s1 int product =1; //s2 for (int i=1; i<=n; i++) //s3 sum=sum + i; //s4 product = product * i; //s5 fun(sum, product); }} //s6 { {

  14. Near-Miss Software CloneRenaming Identifiers and Literal Values void sumProd(int n) { //s0 int sum=0; //s1 int product =1; //s2 for (int i=1; i<=n; i++) { //s3 sum=sum + i; //s4 product = product * i; //s5 fun(sum, product); }} //s6 Type II Reuse by copy and paste Renaming of identifiers Renaming of Literals and Types sumProd=>addTimes sum=>add product=>times void sumProd(int n) { //s0 double sum=0.0; //s1 double product =1.0; //s2 for (int i=1; i<=n; i++) { //s3 sum=sum + i; //s4 product = product * i; //s5 fun(sum, product); }} //s6 void addTimes(int n) { //s0 int add=0; //s1 int times =1; //s2 for (int i=1; i<=n; i++) { //s3 add=add + i; //s4 times = times * i; //s5 fun(add, times); }} //s6 0=>0.0 1=>1.0 int=>double

  15. Near-Miss Software Clone Statements added/deleted/modified in copied fragments void sumProd(int n) { //s0 int sum=0; //s1 int product =1; //s2 for (int i=1; i<=n; i++) { //s3 sum=sum + i; //s4 product = product * i; //s5 fun(sum, product); }} //s6 Type III Reuse by copy and paste Deletions of lines Addition of new of lines Modification of lines void sumProd(int n) { //s0 int sum=0; //s1 int product =1; //s2 for (int i=1; i<=n; i++) //s3 if (i % 2 == 0){ //s3b sum=sum + i; //s4 product = product * i; //s5 fun(sum, product); }} //s6 void sumProd(int n) { //s0 int sum=0; //s1 int product =1; //s2 for (int i=1; i<=n; i++) { //s3 if (i % 2 == 0)sum+= i; //s4m product = product * i; //s5 fun(sum, product); }} //s6 void sumProd(int n) { //s0 int sum=0; //s1 int product =1; //s2 for (int i=1; i<=n; i++) { //s3 sum=sum + i; //s4 //s5 line deleted fun(sum, product); }} //s6

  16. Near-Miss Software CloneStatements reordering/control replacements void sumProd(int n) { //s0 int sum=0; //s1 int product =1; //s2 for (int i=1; i<=n; i++) { //s3 sum=sum + i; //s4 product = product * i; //s5 fun(sum, product); }} //s6 Type IV Reuse by copy and paste Control Replacements Reordering of Statements void sumProd(int n) { //s0 int sum=0; //s1 int product =1; //s2 int i = 0; //s7 while (i<=n) { //s3’ sum=sum + i; //s4 product = product * i; //s5 fun(sum, product); //s6 i =i + 1; }} //s8 void sumProd(int n) { //s0 int product =1; //s2 int sum=0; //s1 for (int i=1; i<=n; i++) { //s3 sum=sum + i; //s4 product = product * i; //s5 fun(sum, product); }} //s6

  17. Mutation Operators for Cloning • For each of the fine-grained clone types of the clone taxonomy, • We built mutation operators for cloning • We use TXL [Cordy SCP’06] in implementing the operators • Tested with • C, C# and Java

  18. Mutation Operators for Cloning • For Type I Clones

  19. mCC: Changes in Comments Line Original Mutated Line 1 2 3 4 5 6 7 8 if (x==5) { a=1; } else { a=0; } 1 2 3 4 5 6 7 8 if (x==5) { a=1; } else //C { a=0; } mCC

  20. mCF: Changes in formatting Line Original Mutated Line 1 2 3 4 5 6 7 8 if (x==5) { a=1; } else { a=0; } if (x==5) { a=1; } else { a=0; } 1 2 3 4 5 6 7 8 mCF

  21. mCF: Changes in formatting Line Original Mutated Line 1 2 3 4 5 6 7 8 if (x==5) { a=1; } else { a=0; } if (x==5) { a=1; } else { a=0; } 1 2 3 4 5 6 7 8 mCF One or more changes can be made at a time

  22. Mutation Operators for Cloning • For Type II Clones

  23. mSRI: Systematic renaming of identifiers Line Original Mutated Line 1 2 3 4 5 6 7 8 if (x==5) { a=1; } else { a=0; } if (x==5) { b=1; } else { b=0; } 1 2 3 4 5 6 7 8 mSRI

  24. mSRI: Systematic renaming of identifiers Line Original Mutated Line 1 2 3 4 5 6 7 8 if (x==5) { a=1; } else { a=0; } if (x==5) { b=1; } else { b=0; } 1 2 3 4 5 6 7 8 mSRI

  25. mARI: Arbitrary renaming of identifiers Line Original Mutated Line 1 2 3 4 5 6 7 8 if (x==5) { a=1; } else { a=0; } if (x==5) { b=1; } else { c=0; } 1 2 3 4 5 6 7 8 mARI

  26. Mutation Operators for Cloning • For Type III Clones

  27. mSIL: Small Insertion within a Line Line Original Mutated Line 1 2 3 4 5 6 7 8 if (x==5) { a=1; } else { a=0; } if (x==5) { a=1 + x; } else { a=0; } 1 2 3 4 5 6 7 8 mSIL

  28. mILs: Insertions of One or More Lines Line Original Mutated Line 1 2 3 4 5 6 7 8 9 if (x==5) { a=1; } else { a=0; } if (x==5) { a=1; } else { a=0; y=y + c; } 1 2 3 4 5 6 7 8 mILs

  29. Mutation Operators for Cloning • For Type IV Clones

  30. Mutation Operators for Cloning • Combinations of mutation operators if (x==5) { a=1; } else { a=0; } if (x==5) { b=1+x; } else //c { b=0; } if (x==5) { b=1; } else //c { b=0; } if (x==5) { a=1; } else //c { a=0; } mSIL mSRI mCC mCC + mSRI + mSIL Original Final Mutated

  31. The Evaluation Framework • Generation Phase • Create artificial clone pairs (using mutation analysis) • Inject to the code base • Evaluation Phase • How well and how efficiently the known clone pairs are detected by the tool(s)

  32. Original Fragment Randomly picks a fragment Generation Phase: Base Case oCF(f3, 10, 20) mOCF(f1, 2, 12) OP/Type: mCC CP: (oCF, moCF) Database Code Base Mutation Operators Pick an operator (say mCC) and apply Randomly injects into the code base Mutated Fragment

  33. Evaluation Phase: Base Case oCF(f3, 10, 20) Subject Tool: T mOCF(f1, 2, 12) OP/Type: mCC CP: (oCF, moCF) Database Clone Report Mutated Code Base Tool Evaluation

  34. (oCF, moCF) UR T Unit Recall • For known clone pair, (oCF, moCF), of type mCC, the unit recall is: 1, if (oCF, moCF) is killed by T in the mutated code base = 0, otherwise

  35. Definition of killed(oCF, moCF) • (oCF, moCF) has been detected by the subject tool, T • That is a clone pair, (CF1, CF2) detected by T matches or subsumes (oCF, moCF) • We use source coordinates of the fragments to determine this • First match the full file names of the fragments, then check for begin-end line numbers of the fragments within the files

  36. Unit Precision • Say, for moCF, Treports k clone pairs, • (moCF, CF1), (moCF, CF2),…, (moCF, CFk) • Also let, v of them are valid clone pairs,then • For known clone pair, (oCF, moCF), of type mCC, the unit precision is: v: Total no of valid clone pairs with moCF (oCF, moCF) UP = k:Total no of clone pairs with moCF T

  37. Automatic Validation of Known Clone Pairs • Built a clone pair validator based on NICAD (Roy and Cordy ICPC’08) • Unlike NICAD, it is not a clone detector • It only works with a specific given clone pair • It is aware of the mutation operator applied • Depending on the inserted clone, detection parameters are automatically tuned

  38. Random Fragment Selection Random Fragment Injection Mutator 1 Random Fragments Mutator 2 Mutator N Generation Phase: General Case Injected Mutant Source Coordinate Database Original Code Base Randomly Injected Mutant Code Bases Randomly Mutated Fragments

  39. Tool 1 Tool 2 Tool K Evaluation Phase: General Case Injected Mutant Source Coordinate Database 1 Tool 1 Mutant 1 Report Mutant 1 Tool Eval 2 Statistical Analysis and Reporting Mutant 2 Tool Eval M Tool 2 Mutant 1 Report Randomly Injected Mutant Code Bases Evaluation Database Mutant M Tool Eval Tool K Mutant 1 Report

  40. (oCFi, moCFi) mCC (oCFi, moCFi) Type I R UR UR R T T T T Recall • With mCC,m fragments are mutated and each injected n times to the code base m * n ∑ i=1 = m * n (m * n) * (3 + 4) ∑ i=1 = (m * n) * (3 + 4)

  41. overall (oCFi, moCFi) R UR T T Overall Recall • l clone mutation operators and c of their combinations applied n times to m selected code fragments, so (m * n) * (l + c) ∑ i=1 = (m * n) * (l + c)

  42. m * n m * n ∑ ∑ i=1 Type I mCC ki vi P vi ki P T T Precision • With mCC,m fragments are mutated and each injected n times to the code base m * n * (3 + 4) ∑ i=1 = = m * n * (3 + 4) ∑ i=1 i=1

  43. Overall P vi ki T Overall Precision • l clone mutation operators and c of their combinations applied n times to m selected code fragments, so m * n * (l + c) ∑ i=1 = m * n * (l + c) ∑ i=1

  44. Example Use of the Framework • Select one or more subject systems • Case one: Evaluate single tool • We evaluate NICAD [Roy and Cordy ICPC’08 ] • Case two: Compare a set of tools • Basic NICAD [Roy and Cordy WCRE’08] • Flexible Pretty-Printed NICAD [Roy and Cordy ICPC’08 ] • and Full NICAD [Roy and Cordy ICPC’08 ]

  45. Subject Systems

  46. Recall Measurement

  47. Precision Measurement

  48. Other Issues • Time and memory requirements • Can report fine-grained comparative timing and memory requirements for subject tools • Scalability of the framework • Can work subject system of any size, depending on the scalability of the subject tools • Uses multi-processing to balance the load • Adapting tools to the framework • The subject tool should run in command line • Should provide textual reports of the found clones

  49. Related Work: Tool Comparison Experiments • Baily and Burd SCAM’02 • 3 CDs + 2 PDs • Bellon et al. TSE’07 • Extensive to-date • 6 CDs, C and Java systems • Koschke et al. WCRE’06 • Rysselberge and Demeyer ASE’04

  50. Related Work: Single Tool Evaluation Strategies • Text-based • Only example-based evaluation, no precision and recall evaluations except NICAD • Token-based • CP-Miner, for precision by examining 100 randomly selected fragments • AST-based • Cpdetector, in terms of both precision and recall (Type I & II). • Deckard, for precision with examing 100 segments • Metrics-based • Kontogianis evaluated with IR-approach, system was oracled manually. • Graph-based • Gabel et al., precision examined 30 fragments per experiment.

More Related