CSE 160 Discussion Section. Winter 2017 Week 3

Transcription

1 CSE 160 Discussion Section Winter 2017 Week 3

2 Homework 1 - Recap & a few points ComputeMandelbrotPoint func() in smdb.cpp does the job serially. You will have to do the same task in parallel manner in pmdb.cpp block & cyclic partitioning methods taught in the lecture to be used.

3 Recap: Block Partitioning Chunk size = 0, Run without -c option Split the computational box into regions - either horizontal or vertical dimy/nt or dimx/nt Assign a thread to each region Embarrassingly parallel, so no communication between threads

4 Recap: Cyclic Partitioning Round Robin : thread t gets evenly spaced chunks : spaced as chunksize*nt rows apart So core 1 gets strips : 2*1, 2+1*2*3, 2+2*2*3 Balances load evenly Run using -c <chunk size>

5 Notes on Experiments Strong scaling Run for number of threads = 1, 2, 4, 8. Plot parallel speed-up vs number of threads Varying chunk size 8 threads, vary chunk size (-c) from 1 to 8. Plot running time vs chunk size Block vs Cyclic (c=1) 2, 4, 8 threads Block vs Cyclic (c=1) for different bounding box -b , 4, 8 threads

6 Regarding submission: Present your data in Tables / Plots Clear Titles for Table/Plot ex: Strong Scaling Plots using any tool of your choice (Excel/matplotlib/Latex.) Label Rows/Cols of tables and provide axis for plots Brief Analysis on your experiment findings in Report Add Details on implementation (so that we can provide partial credit if code fails to compile) In Report Name [Checklist 1] to help us understand that you have performed the task*

7 Running Jobs on Bang Cluster Interactive : qlogin Non - Interactive Refer : /static/bang/runningjobs.html

8 Interactive Jobs qlogin New shell within $Home dir Edit & Compile code, Run commands on compute node Short/Small jobs Cannot Submit Non-interactive jobs Exclusive Access for 20 mins to a compute node with 8 nodes

9 Non-Interactive Jobs To collect performance measurements To repeat jobs multiple times Space sharing - dedicated access $qsub batch_bang.sh $qstat -u username $qstat -u * - to see all jobs running in queue $qdel job-id to remove a job from queue $qconf -sq debug.q -queue s config parameters $qconf -sq debug.q grep -i h_rt - to get the time limit to run jobs

10 GNU Debugger Open-source debugger Facilities: breakpoints, watches, stepping through code Provides some facilities for multi-threaded programs as well Run with GDB: $gdb./main

11 GNU Debugger - Multi-threaded programs (gdb) b main add a breakpoint at the entry to the function called main Breakpoint 1 at 0x400f46: file main.cpp, line 19. (gdb) r run the program... (gdb) n step to the next line 20 thread t1(foo); line in source code (gdb) n step to the next line [New Thread 0x7ffff6fd6700 (LWP 1418)] 21 thread t2(bar); line in source code (gdb) n [Thread 0x7ffff6fd6700 (LWP 1418) exited] notification of thread completion [New Thread 0x7ffff67d5700 (LWP 1419)] notification of thread creation [Thread 0x7ffff67d5700 (LWP 1419) exited] notification of thread completion 22 cout << x << "\n"; line in source code

12 GNU Debugger - Multi-threaded programs. (gdb) info threads get information about current threads Id Target Id Frame 2 Thread 0x7ffff6fd6700 (LWP 1544) "main" GI nptl_death_event () at events.c:31 * 1 Thread 0x7ffff7fd5780 (LWP 1543) "main" main () at main.cpp:21 * indicates we are controlling thread 1 currently

13 GNU Debugger - Multi-threaded programs. (gdb) info threads get information about current threads Id Target Id Frame 2 Thread 0x7ffff6fd6700 (LWP 1544) "main" GI nptl_death_event () at events.c:31 * 1 Thread 0x7ffff7fd5780 (LWP 1543) "main" main () at main.cpp:21 (gdb) thread 2 switch to thread 2 [Switching to thread 2 (Thread 0x7ffff6fd6700 (LWP 1544))]

14 GNU Debugger - Multi-threaded programs. (gdb) info threads get information about current threads Id Target Id Frame 2 Thread 0x7ffff6fd6700 (LWP 1544) "main" GI nptl_death_event () at events.c:31 * 1 Thread 0x7ffff7fd5780 (LWP 1543) "main" main () at main.cpp:21 (gdb) thread 2 switch to thread 2 [Switching to thread 2 (Thread 0x7ffff6fd6700 (LWP 1544))] (gdb) info threads get information about current threads Id Target Id Frame * 2 Thread 0x7ffff6fd6700 (LWP 1544) "main" GI nptl_death_event () at events.c:31 1 Thread 0x7ffff7fd5780 (LWP 1543) "main" main () at main.cpp:21 * indicates we are controlling thread 2 currently

15 Valgrind Debugging and Profiling Tool Makes program faster and performs correctness checks Checks for : Thread Errors helgrind Memory Related Errors, Memory leaks : memcheck

16 Valgrind Open-source debugging tool Install on your laptop using standard OS commands Ubuntu : sudo apt-get install valgrind Compile with -g flag gcc -g main.cpp -o main In A2: make gdb=1

17 Valgrind - Detecting Thread Errors int x = 0; void foo() { x++; } void bar() { x--; } int main() { x = 0; thread t1(foo); thread t2(bar); t1.join(); t2.join(); return 0; }

18 Valgrind - Detecting Thread Errors int x = 0; void foo() { x++; } void bar() { x--; } int main() { x = 0; thread t1(foo); thread t2(bar); t1.join(); t2.join(); return 0; } $ g++ -g main.cpp -o main -std=c++11 -pthread $ valgrind --tool=helgrind./main. Possible data race during read of size 4 at 0x6042BC by thread #1 ==1085== Locks held: none ==1085== at 0x400F4C: main (main.cpp:20) ==1085== ==1085== This conflicts with a previous write of size 4 by thread #3 ==1085== Locks held: none ==1085== at 0x400F0F: bar() (main.cpp:12) ==1085==..

19 Valgrind - Detecting Memory Leaks Memcheck can detect: Use of uninitialised memory Reading/writing memory after it has been free'd Reading/writing off the end of malloc'd blocks Reading/writing inappropriate areas on the stack Memory leaks -- where pointers to malloc'd blocks are lost forever Mismatched use of malloc/new/new [] vs free/delete/delete [] Overlapping src and dst pointers in memcpy() and related functions Some misuses of the POSIX pthreads API

20 Valgrind - Detecting Memory Leaks #include <stdio.h> int main() { char *p; // Allocation #1 of 19 bytes p = (char *) malloc(19); // Allocation #2 of 12 bytes p = (char *) malloc(12); free(p); $gcc -o test -g test.c $valgrind --tool=memcheck --leak-check=yes --show-reachable=yes --num-callers=20 --track-fds=yes./test // Allocation #3 of 16 bytes p = (char *) malloc(16); return 0; }

21 Valgrind - Detecting Memory Leaks $gcc -o test -g test.c $valgrind --tool=memcheck --leak-check=yes --show-reachable=yes --num-callers=20 --track-fds=yes./test Output: ==9704== Memcheck, a memory error detector for x86-linux. ==9704== Copyright (C) , and GNU GPL'd, by Julian Seward et al. ==9704== Using valgrind-2.2.0, a program supervision framework for x86-linux. ==9704== Copyright (C) , and GNU GPL'd, by Julian Seward et al. ==9704== For more details, rerun with: -v ==9704== ==9704== ==9704== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 11 from 1) ==9704== malloc/free: in use at exit: 35 bytes in 2 blocks. ==9704== malloc/free: 3 allocs, 1 frees, 47 bytes allocated. ==9704== For counts of detected errors, rerun with: -v ==9704== searching for pointers to 2 not-freed blocks. ==9704== checked bytes. ==9704== ==9704== 16 bytes in 1 blocks are definitely lost in loss record 1 of 2 ==9704== at 0x1B903D38: malloc (vg_replace_malloc.c:131) ==9704== by 0x80483BF: main (test.c:15) ==9704== ==9704== ==9704== 19 bytes in 1 blocks are definitely lost in loss record 2 of 2 ==9704== at 0x1B903D38: malloc (vg_replace_malloc.c:131) ==9704== by 0x : main (test.c:8) ==9704== ==9704== LEAK SUMMARY: ==9704== definitely lost: 35 bytes in 2 blocks. ==9704== possibly lost: 0 bytes in 0 blocks. ==9704== still reachable: 0 bytes in 0 blocks. ==9704== suppressed: 0 bytes in 0 blocks.

22 Other uses of Valgrind Cachegrind Cache profiling Callgrind Call-graph generation Can be used for Deadlock detection DRD - Another thread error detection tool under Valgrind Link for DRD info Memcheck is not perfect. Occasionally produces False Positives 99% of time correct