CalFuzzer Tutorial: Analysis of Concurrent Programs

CalFuzzer is a dynamic analysis and active testing framework developed by Prof. Koushik Sen's group at UC Berkeley. It provides infrastructure to analyze and test concurrent Java programs, detecting and predicting concurrency bugs. The tool modifies Java bytecode through instrumentation, enabling the insertion of probes to extract runtime information and control thread scheduling during testing. CalFuzzer inserts probes at specific sites to monitor program behavior and offers various functionalities for bug prediction and testing.

• CalFuzzer
• Dynamic Analysis
• Concurrent Programs
• Testing Framework
• Java

juanpabl Follow

Uploaded on Oct 06, 2024 | 0 Views

Download Presentation

Please find below an Image/Link to download the presentation.

The content on the website is provided AS IS for your information and personal use only. It may not be sold, licensed, or shared on other websites without obtaining consent from the author.If you encounter any issues during the download, it is possible that the publisher has removed the file from their server.

You are allowed to download the files provided on this website for personal or commercial use, subject to the condition that they are used lawfully. All files are the property of their respective owners.

The content on the website is provided AS IS for your information and personal use only. It may not be sold, licensed, or shared on other websites without obtaining consent from the author.

Presentation Transcript

1. CS492B Analysis of Concurrent Programs CalFuzzer Tutorial Prof. Moonzoo Kim Computer Science, KAIST

2. CalFuzzer Developed by Prof. Koushik Sen s group at UC Berkeley http://srl.cs.berkeley.edu/~ksen/calfuzzer/ Dynamic analysis + Active testing framework for concurrent Java programs Dynamic analysis: detect/predict concurrency bugs Active testing: generate thread scheduling for inducing detected/predicted concurrency bugs Provide useful infra-structure to construct various dynamic analysis and testing techniques 2 CalFuzzer Tutorial, Prof. Moonzoo Kim

3. CalFuzzer Framework Target program s Java bytecode Instrumented Java bytecode Instrume- ntation phase Instrumentor Dynamic analysis phase Bug prediction information Instrumented Java bytecode Dynamic analyzer Instrumented Java bytecode Testing phase Test Test executions generator Bug prediction information CalFuzzer 3 CalFuzzer Tutorial, Prof. Moonzoo Kim

4. Instrumentation Calfuzzer modifies a target Javabyte code to insert probes each of which executes before/after certain operations e.g. before every memory read instruction, insert a probe to call Observer.readBefore(thread, addr), which is defined by a user In the dynamic analysis phase, user-written probes are executed to extract runtime information e.g. a user writes Observer.readBefore(thread, addr) to log which thread reads which memory addresses In the testing phase, a user can write probes to pause/continue threads to control a thread scheduler as s/he wants 4 CalFuzzer Tutorial, Prof. Moonzoo Kim

5. Instrumentation Example public class Account { public synchronized int balance() { return balance ; } } ... public synchronized int balance(); Code: aload_0 getfield #2 // Field balance ireturn <Source code> <Bytecode> ... public synchronized int balance(); Code: ... invokestatic #39 //invoke Observer.lockAfter(int) ... invokestatic #40 //invoke Observer.readBefore(thread,addr) aload_0 getfield #2 // Field balance ireturn after lock(this) before read(balance) <Instrumented code> 5 CalFuzzer Tutorial, Prof. Moonzoo Kim

6. CalFuzzer Instrumentation CalFuzzer inserts the probes to call the following functions at the following sites Probe method Instrumented site Before starting a program initialize() finish() methodEnterBefore() methodExitAfter() lockBefore()/lockAfter() When a target program terminates Before entering a method call After returning from a method call Before/after entering a synchronized block, or invoking a synchronized method After existing a synchronized block/method unlockAfter() startBefore() joinAfter() waitAfter() notifyBefore()/ notifyAllBefore() readBefore()/readAfter() Before a new thread is starting After join with a child thread After awaken from a waiting Before notify() / notifyAll() Before/after reading a memory address (i.e., object field reference, array access) Before/after writing a memory address writeBefore()/writeAfter() 6 CalFuzzer Tutorial, Prof. Moonzoo Kim

7. Bytecode Instrumentation CalFuzzer uses Soot for bytecode instrumentation Soot is a Java bytecode engineering framework http://www.sable.mcgill.ca/soot/tutorial/index.html Soot converts a given bytecode to a Jimple code Jimple is a Soot intermediate representation Jimple is 3-addressed typed code in a control-flow graph Each variable has its name and type Jimple code is easier to analyze and instrument than bytecode Only 15 kinds of statements (bytecode has more than 200 kinds of instructions) Using Soot, the Calfuzzer instrumentation module 1. converts target bytecode to jimple code, and 2. modifies the Jimple code to insert probes, and 3. compiles the modified Jimple code into bytecode 7 CalFuzzer Tutorial, Prof. Moonzoo Kim

8. Dynamic Analysis Phase CalFuzzer binds an instrumented program with an AnalysisImplinstance (i.e., analyzer) which implements each probe method CalFuzzer instruments a given target program and then executes the instrumented program with an analyzer Dynamic analyzer Test generator Target program execution Data race detector Deadlock detector Atomicity detector Data race tester Deadlock tester Atomicity tester Thread-1 Thread-2 Thread-3 Thread schedule generator readBefore() Observer read(X) CalFuzzer runtime modules 8 CalFuzzer Tutorial, Prof. Moonzoo Kim

9. Analyzer An analyzer should implements the probe methods to monitor and analyze a target program execution (i.e., implement AnalysisImpl) For each test execution, CalFuzzer creates one instance of analyzer for monitoring a target program execution In an execution, a thread executes probes before and after certain operations Multiple threads may execute methods of an analyzer concurrently A user has to be careful not to raise concurrency errors caused by his/her own probes See src/javato/activetesting/BlankAnalysis.java 9 CalFuzzer Tutorial, Prof. Moonzoo Kim

10. List of Useful CalFuzzer Probes Initialization & finalization public void initialize(), public void finish() Targeting methods public void methodEnterBefore(Integer iid, Integer thread, String method) public void methodExitAfter(Integer iid, Integer therad, String method) Targeting lock operations public void lockBefore(Integer iid, Integer thread, Integer lock, Object actualLock) public void lockAfter(Integer iid, Integer thread, Integer lock, Object actualLock) public void unlockAfter(Integer iid, Integer thread, Integer lock, Object actualLock) Targeting read/write operations public void readBefore(Integer iid, Integer thread, Long memory, boolean isVolatile) public void readAfter(Integer iid, Integer thread, Long memory, boolean isVolatile) public void writeBefore(Integer iid, Integer thread, Long memory, boolean isVolatile) public void writeAfter(Integer iid, Integer thread, Long memory, boolean isVolatile) Targeting wait-notify operations Targeting thread operations 10

11. Initialize and Finish public void initialize() Executed before a target program starts To initialize the data structure and read user inputs public void finish() Executed when a target program terminates Analyze the monitored data and print out the result 11 CalFuzzer Tutorial, Prof. Moonzoo Kim

12. Method Related Probes public void methodEnterBefore(Integer iid, Integer thread, String method) Executed before a target method is called iid: the unique identifier of an inserted probe (i.e., code location) thread: the unique identifier of a current thread method: the signature of the called method public void methodExitAfter(Integer iid, Integer therad, String method) Executed after a method call is returned 12 CalFuzzer Tutorial, Prof. Moonzoo Kim

13. Locking Related Probe public void lockBefore(Integer iid, Integer thread, Integer lock, Object actualLock) Executed before a synchronized block or a synchronized method call lock: the unique identifier of a target lock (i.e. object) actualLock: the memory address to a target lock public void lockAfter(Integer iid, Integer thread, Integer lock, Object actualLock) Executed after entering a synchronized block or a synchronized method public void unlockAfter(Integer iid, Integer thread, Integer lock, Object actualLock) Executed after existing a synchronized block or a synchronized method 13 CalFuzzer Tutorial, Prof. Moonzoo Kim

14. Data Access Related Probes (1/2) public void readBefore(Integer iid, Integer thread, Long memory, boolean isVolatile) Executed before every read operation memory: the unique identifier of a target memory address isVolatile: whether or not a target memory address is volatile (free from data race) http://en.wikipedia.org/wiki/Volatile_variable public void readAfter(Integer iid, Integer thread, Long memory, boolean isVolatile) Executed after every read operation public void writeBefore(Integer iid, Integer thread, Long memory, boolean isVolatile) Executed before every write operation public void writeAfter(Integer iid, Integer thread, Long memory, boolean isVolatile) Executed after every write operation 14 CalFuzzer Tutorial, Prof. Moonzoo Kim

15. Data Access Related Probes (2/2) Race conditions may occur when there is no synchronization in data access probes Thread-1 Thread-2 writeBefore(x): assume that Thread-1 will access x next writeBefore(x): write(x) write(x) 15 CalFuzzer Tutorial, Prof. Moonzoo Kim

16. Wait and Notify Related Probes public void waitAfter(Integer iid, Integer thread, Integer lock) Executed after awaken from a waiting operation In Java, a thread can wait on an object, similar to lock/unlock public void notifyBefore(Integer iid, Integer thread, Integer lock) Executed before a notify operation public void notifyAllBefore(Integer iid, Integer thread, Integer lock) Executed after a notify operation 16 CalFuzzer Tutorial, Prof. Moonzoo Kim

17. Thread Related Probes public void startBefore(Integer iid, Integer parent, Integer child) Executed before starting a new thread parent: the unique identifier of the thread that creates a new thread child: the unique identifier of a new thread public void joinAfter(Integer iid, Integer parent, Integer child) Executed after the join operation parent: the unique identifier of the thread that joins on a child thread child: the unique identifier of the child thread 17 CalFuzzer Tutorial, Prof. Moonzoo Kim

18. Useful APIs javato.activetesting.common.Parameters contains the environment configurations on CalFuzzers javato.activetesting.analysis.Observer.getIidToLine(iid) returns a code location as String for a given iid 18 CalFuzzer Tutorial, Prof. Moonzoo Kim

19. Ant Script CalFuzzer uses Apache Ant to build (i.e. compile Java source code) and execute analysis techniques The build script is defined in build.xml The execution scripts are defined in run.xml clean instr Run the generic instrumentor for a target program javato.work.dir: the work directory of a target program javato.app.main.class: the class name of a target program analysis-once Generate a test case execution with a dynamic analyzer javato.activetesting.analysis.class: the class name of the dynamic analysis technique in CalFuzzer 19 CalFuzzer Tutorial, Prof. Moonzoo Kim