cs 61a cs 98 52
play

CS 61A/CS 98-52 Mehrdad Niknami University of California, Berkeley - PowerPoint PPT Presentation

Mar 09, 2023 •511 likes •2.21k views

CS 61A/CS 98-52 Mehrdad Niknami University of California, Berkeley Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 1 / 25 Preliminaries Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 2 / 25 Preliminaries Today, were going to learn how to

  1. Terminology Some basic terminology: Process : A running program Processes cannot access each others’ memory by default Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 5 / 25

  2. Terminology Some basic terminology: Process : A running program Processes cannot access each others’ memory by default Thread : A unit of program flow ( N threads = n independent executions of code) Threads maintain their own execution contexts in a given process Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 5 / 25

  3. Terminology Some basic terminology: Process : A running program Processes cannot access each others’ memory by default Thread : A unit of program flow ( N threads = n independent executions of code) Threads maintain their own execution contexts in a given process Thread context : All the information a thread needs to run code This includes the location of the code that it is currently being executing, as well as its current stack frame (local variables, etc.) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 5 / 25

  4. Terminology Some basic terminology: Process : A running program Processes cannot access each others’ memory by default Thread : A unit of program flow ( N threads = n independent executions of code) Threads maintain their own execution contexts in a given process Thread context : All the information a thread needs to run code This includes the location of the code that it is currently being executing, as well as its current stack frame (local variables, etc.) Concurrency : Overlapping operations ( X begins before Y ends) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 5 / 25

  5. Terminology Some basic terminology: Process : A running program Processes cannot access each others’ memory by default Thread : A unit of program flow ( N threads = n independent executions of code) Threads maintain their own execution contexts in a given process Thread context : All the information a thread needs to run code This includes the location of the code that it is currently being executing, as well as its current stack frame (local variables, etc.) Concurrency : Overlapping operations ( X begins before Y ends) Parallelism : Simultaneously-occurring operations (multiple operations happening at the same time ) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 5 / 25

  6. Terminology Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 6 / 25

  7. Terminology Parallel operations are always concurrent by definition Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 6 / 25

  8. Terminology Parallel operations are always concurrent by definition Concurrent operations need not be in parallel (open door, open window, close door, close window) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 6 / 25

  9. Terminology Parallel operations are always concurrent by definition Concurrent operations need not be in parallel (open door, open window, close door, close window) Parallelism gives you a speed boost (multiple operations at the same time), but requires N processors for N × speedup Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 6 / 25

  10. Terminology Parallel operations are always concurrent by definition Concurrent operations need not be in parallel (open door, open window, close door, close window) Parallelism gives you a speed boost (multiple operations at the same time), but requires N processors for N × speedup Concurrency allows you to avoid stopping one thing before starting another, and can occur on a single processor Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 6 / 25

  11. Concepts Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 25

  12. Concepts Distributed computation (running on multiple machines) is more difficult: Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 25

  13. Concepts Distributed computation (running on multiple machines) is more difficult: Needs fault-tolerance (more machines = higher failure probability) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 25

  14. Concepts Distributed computation (running on multiple machines) is more difficult: Needs fault-tolerance (more machines = higher failure probability) Lack of shared memory Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 25

  15. Concepts Distributed computation (running on multiple machines) is more difficult: Needs fault-tolerance (more machines = higher failure probability) Lack of shared memory More limited communication bandwidth (network slower than RAM) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 25

  16. Concepts Distributed computation (running on multiple machines) is more difficult: Needs fault-tolerance (more machines = higher failure probability) Lack of shared memory More limited communication bandwidth (network slower than RAM) Time becomes problematic to handle Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 25

  17. Concepts Distributed computation (running on multiple machines) is more difficult: Needs fault-tolerance (more machines = higher failure probability) Lack of shared memory More limited communication bandwidth (network slower than RAM) Time becomes problematic to handle Rich literature, e.g. actor-based models of computation (MoC) such as discrete-event, synchronous-reactive, synchronous dataflow, etc. for analyzing/designing systems with guaranteed performance or reliability Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 25

  18. Threading Threading example: import threading t = threading.Thread(target= print , args=('a',)) t.start() print ('b') # may print 'b' before or after 'a' t.join() # wait for t to finish Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 8 / 25

  19. Threading Race condition: Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 25

  20. Threading Race condition: When a thread attempts to access something being modified by another thread. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 25

  21. Threading Race condition: When a thread attempts to access something being modified by another thread. Race conditions are generally bad. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 25

  22. Threading Race condition: When a thread attempts to access something being modified by another thread. Race conditions are generally bad. Example: import threading lst = [ 0 ] def f (): lst[ 0 ] += 1 # write 1 might occur after read 2 t = threading.Thread(target=f) t.start() f() t.join() assert lst[ 0 ] in [ 1 , 2 ] # could be any of these! Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 25

  23. Concurrency Control Mutex ( Lock in Python): Object that can prevent concurrent access ( mut ual- ex clusion ). Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 10 / 25

  24. Concurrency Control Mutex ( Lock in Python): Object that can prevent concurrent access ( mut ual- ex clusion ). Example: import threading lock = threading.Lock() lst = [ 0 ] def f (): lock.acquire() # waits for mutex to be available lst[ 0 ] += 1 # only one thread may run this code lock.release() # makes mutex available to others t = threading.Thread(target=f) t.start() f() t.join() assert lst[ 0 ] in [ 2 ] # will always succeed Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 10 / 25

  25. Concurrency Control 1 However, Python code can release GIL when calling non-Python code. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 11 / 25

  26. Concurrency Control Sadly, in CPython, multithreaded operations cannot occur in parallel, because there is a “global interpreter lock” (GIL). Therefore, Python code cannot be sped up in CPython. 1 1 However, Python code can release GIL when calling non-Python code. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 11 / 25

  27. Concurrency Control Sadly, in CPython, multithreaded operations cannot occur in parallel, because there is a “global interpreter lock” (GIL). Therefore, Python code cannot be sped up in CPython. 1 To obtain parallelism in CPython, you can use multiprocessing : running another copy of the program and communicating with it. 1 However, Python code can release GIL when calling non-Python code. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 11 / 25

  28. Concurrency Control Sadly, in CPython, multithreaded operations cannot occur in parallel, because there is a “global interpreter lock” (GIL). Therefore, Python code cannot be sped up in CPython. 1 To obtain parallelism in CPython, you can use multiprocessing : running another copy of the program and communicating with it. Jython, IronPython, etc. can run Python in parallel, and most other languages support parallelism as well. 1 However, Python code can release GIL when calling non-Python code. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 11 / 25

  29. Inter-Thread and Inter-Process Communication (IPC) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 25

  30. Inter-Thread and Inter-Process Communication (IPC) Threads/processes need to communicate. Common techniques: Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 25

  31. Inter-Thread and Inter-Process Communication (IPC) Threads/processes need to communicate. Common techniques: Shared memory: mutating shared objects (if all on 1 machine) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 25

  32. Inter-Thread and Inter-Process Communication (IPC) Threads/processes need to communicate. Common techniques: Shared memory: mutating shared objects (if all on 1 machine) Pros: Reduces copying of data (faster/less memory) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 25

  33. Inter-Thread and Inter-Process Communication (IPC) Threads/processes need to communicate. Common techniques: Shared memory: mutating shared objects (if all on 1 machine) Pros: Reduces copying of data (faster/less memory) Cons: Must block execution until lock is acquired (slow) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 25

  34. Inter-Thread and Inter-Process Communication (IPC) Threads/processes need to communicate. Common techniques: Shared memory: mutating shared objects (if all on 1 machine) Pros: Reduces copying of data (faster/less memory) Cons: Must block execution until lock is acquired (slow) Message-passing: sending data through thread-safe queues Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 25

  35. Inter-Thread and Inter-Process Communication (IPC) Threads/processes need to communicate. Common techniques: Shared memory: mutating shared objects (if all on 1 machine) Pros: Reduces copying of data (faster/less memory) Cons: Must block execution until lock is acquired (slow) Message-passing: sending data through thread-safe queues Pros: Queue can buffer & work asynchronously (faster) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 25

  36. Inter-Thread and Inter-Process Communication (IPC) Threads/processes need to communicate. Common techniques: Shared memory: mutating shared objects (if all on 1 machine) Pros: Reduces copying of data (faster/less memory) Cons: Must block execution until lock is acquired (slow) Message-passing: sending data through thread-safe queues Pros: Queue can buffer & work asynchronously (faster) Cons: Increases need to copy data (slower/more memory) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 25

  37. Inter-Thread and Inter-Process Communication (IPC) Threads/processes need to communicate. Common techniques: Shared memory: mutating shared objects (if all on 1 machine) Pros: Reduces copying of data (faster/less memory) Cons: Must block execution until lock is acquired (slow) Message-passing: sending data through thread-safe queues Pros: Queue can buffer & work asynchronously (faster) Cons: Increases need to copy data (slower/more memory) Pipes: synchronous version of message-passing (“rendezvous”) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 25

  38. Inter-Thread and Inter-Process Communication (IPC) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 13 / 25

  39. Inter-Thread and Inter-Process Communication (IPC) Message-passing example for parallelizing f ( x ) = x 2 : from multiprocessing import Process, Queue def f (q_in, q_out): while True: x = q_in.get() if x is None: break q_out.put(x ** 2 ) # real work if __name__ == '__main__': # only on main thread qs = (Queue(), Queue()) procs = [Process(target=f, args=qs) for _ in range( 4 )] for proc in procs: proc.start() for i in range( 10 ): qs[ 0 ].put(i) # send inputs for i in range( 10 ): print (qs[ 1 ].get()) # receive outputs for proc in procs: qs[ 0 ].put(None) # notify finished for proc in procs: proc.join() Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 13 / 25

  40. Addition Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 14 / 25

  41. Addition Common parallelism technique: divide-and-conquer Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 14 / 25

  42. Addition Common parallelism technique: divide-and-conquer 1 Divide problem into separate subproblems Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 14 / 25

  43. Addition Common parallelism technique: divide-and-conquer 1 Divide problem into separate subproblems 2 Solve subproblems in parallel Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 14 / 25

  44. Addition Common parallelism technique: divide-and-conquer 1 Divide problem into separate subproblems 2 Solve subproblems in parallel 3 Merge sub-results into main result Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 14 / 25

  45. Addition Common parallelism technique: divide-and-conquer 1 Divide problem into separate subproblems 2 Solve subproblems in parallel 3 Merge sub-results into main result XOR (and AND, and OR) are easy to parallelize: Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 14 / 25

  46. Addition Common parallelism technique: divide-and-conquer 1 Divide problem into separate subproblems 2 Solve subproblems in parallel 3 Merge sub-results into main result XOR (and AND, and OR) are easy to parallelize: 1 Split each n -bit number into p pieces Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 14 / 25

  47. Addition Common parallelism technique: divide-and-conquer 1 Divide problem into separate subproblems 2 Solve subproblems in parallel 3 Merge sub-results into main result XOR (and AND, and OR) are easy to parallelize: 1 Split each n -bit number into p pieces 2 XOR each n / p -bit pair of numbers independently Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 14 / 25

  48. Addition Common parallelism technique: divide-and-conquer 1 Divide problem into separate subproblems 2 Solve subproblems in parallel 3 Merge sub-results into main result XOR (and AND, and OR) are easy to parallelize: 1 Split each n -bit number into p pieces 2 XOR each n / p -bit pair of numbers independently 3 Put back the bits together Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 14 / 25

  49. Addition Common parallelism technique: divide-and-conquer 1 Divide problem into separate subproblems 2 Solve subproblems in parallel 3 Merge sub-results into main result XOR (and AND, and OR) are easy to parallelize: 1 Split each n -bit number into p pieces 2 XOR each n / p -bit pair of numbers independently 3 Put back the bits together Can we do something similar with addition ? Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 14 / 25

  50. Addition Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  51. Addition Let’s go back to addition . Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  52. Addition Let’s go back to addition . We have two n -bit numbers to add. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  53. Addition Let’s go back to addition . We have two n -bit numbers to add. What if we take the same approach for + as for XOR? Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  54. Addition Let’s go back to addition . We have two n -bit numbers to add. What if we take the same approach for + as for XOR? 1 Split each n -bit number into p pieces Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  55. Addition Let’s go back to addition . We have two n -bit numbers to add. What if we take the same approach for + as for XOR? 1 Split each n -bit number into p pieces 2 Add each n / p -bit pair of numbers independently Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  56. Addition Let’s go back to addition . We have two n -bit numbers to add. What if we take the same approach for + as for XOR? 1 Split each n -bit number into p pieces 2 Add each n / p -bit pair of numbers independently 3 Put back the bits together Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  57. Addition Let’s go back to addition . We have two n -bit numbers to add. What if we take the same approach for + as for XOR? 1 Split each n -bit number into p pieces 2 Add each n / p -bit pair of numbers independently 3 Put back the bits together 4 ... Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  58. Addition Let’s go back to addition . We have two n -bit numbers to add. What if we take the same approach for + as for XOR? 1 Split each n -bit number into p pieces 2 Add each n / p -bit pair of numbers independently 3 Put back the bits together 4 ... 5 Profit? Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  59. Addition Let’s go back to addition . We have two n -bit numbers to add. What if we take the same approach for + as for XOR? 1 Split each n -bit number into p pieces 2 Add each n / p -bit pair of numbers independently 3 Put back the bits together 4 ... 5 Profit? No? Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  60. Addition Let’s go back to addition . We have two n -bit numbers to add. What if we take the same approach for + as for XOR? 1 Split each n -bit number into p pieces 2 Add each n / p -bit pair of numbers independently 3 Put back the bits together 4 ... 5 Profit? No? What’s wrong? Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  61. Addition Let’s go back to addition . We have two n -bit numbers to add. What if we take the same approach for + as for XOR? 1 Split each n -bit number into p pieces 2 Add each n / p -bit pair of numbers independently 3 Put back the bits together 4 ... 5 Profit? No? What’s wrong? We need to propagate carries! Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  62. Addition Let’s go back to addition . We have two n -bit numbers to add. What if we take the same approach for + as for XOR? 1 Split each n -bit number into p pieces 2 Add each n / p -bit pair of numbers independently 3 Put back the bits together 4 ... 5 Profit? No? What’s wrong? We need to propagate carries! How long does it take? Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  63. Addition Let’s go back to addition . We have two n -bit numbers to add. What if we take the same approach for + as for XOR? 1 Split each n -bit number into p pieces 2 Add each n / p -bit pair of numbers independently 3 Put back the bits together 4 ... 5 Profit? No? What’s wrong? We need to propagate carries! How long does it take? Θ( n ) time Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  64. Addition Let’s go back to addition . We have two n -bit numbers to add. What if we take the same approach for + as for XOR? 1 Split each n -bit number into p pieces 2 Add each n / p -bit pair of numbers independently 3 Put back the bits together 4 ... 5 Profit? No? What’s wrong? We need to propagate carries! How long does it take? Θ( n ) time (How) can we do better? Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 15 / 25

  65. Addition Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 16 / 25

  66. Addition Key idea #1: Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 16 / 25

  67. Addition Key idea #1: A carry can be either 0 or 1... Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 16 / 25

  68. Addition Key idea #1: A carry can be either 0 or 1... and we add different pieces in parallel ... Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 16 / 25

  69. Addition Key idea #1: A carry can be either 0 or 1... and we add different pieces in parallel ... and then select the correct one based on carry! Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 16 / 25

  70. Addition Key idea #1: A carry can be either 0 or 1... and we add different pieces in parallel ... and then select the correct one based on carry! ⇒ This is called a carry-select adder . Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 16 / 25

  71. Addition Key idea #1: A carry can be either 0 or 1... and we add different pieces in parallel ... and then select the correct one based on carry! ⇒ This is called a carry-select adder . Key idea #2: We can do this recursively . Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 16 / 25

  72. Addition Key idea #1: A carry can be either 0 or 1... and we add different pieces in parallel ... and then select the correct one based on carry! ⇒ This is called a carry-select adder . Key idea #2: We can do this recursively . ⇒ This is called a conditional-sum adder . Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 16 / 25

Download Presentation
Download Policy: The content available on the website is offered to you 'AS IS' for your personal information and use only. It cannot be commercialized, licensed, or distributed on other websites without prior consent from the author. To download a presentation, simply click this link. If you encounter any difficulties during the download process, it's possible that the publisher has removed the file from their server.

Recommend

CPSC 121: Models of Computation Module 11: Models of Computation. CPSC 121 2019W T2 1 Final

CPSC 121: Models of Computation Module 11: Models of Computation. CPSC 121 2019W T2 1 Final

CPSC 121: Models of Computation Module 11: Models of Computation. CPSC 121 2019W T2 1 Final Exam information Announcements: Final exam: Friday April 17 th , 15:30. Office Hours: In the week before the exam. The schedule will be posted on

1.23k views • 71 slides
Computing history Readings: None Topics: Early history Challenges from Hilbert Leading up to

Computing history Readings: None Topics: Early history Challenges from Hilbert Leading up to

Computing history Readings: None Topics: Early history Challenges from Hilbert Leading up to functional programming (Church) Leading up to imperative programming (Turing) Course summary Early history Hilbert Gdel Church Turing

169 views • 15 slides
On the q -binomial coefficients and binomial congruences q -series seminar University of Illinois

On the q -binomial coefficients and binomial congruences q -series seminar University of Illinois

On the q -binomial coefficients and binomial congruences q -series seminar University of Illinois at UrbanaChampaign Armin Straub November 15, 2012 University of Illinois at UrbanaChampaign On the q -binomial coefficients and binomial

1.12k views • 87 slides
Black-box approximation of bivariate functions for FPGAs David B. Thomas, Imperial College

Black-box approximation of bivariate functions for FPGAs David B. Thomas, Imperial College

Black-box approximation of bivariate functions for FPGAs David B. Thomas, Imperial College London Chosen approximation problem Input xy = x x y ( 2 fx Z ) x ( 2 fy Z ) Fixed-point domain: Fixed-point range: r = 2

604 views • 43 slides
A B rie f In tro d u c tio n to th e H is to ry o f C o m p u tin g ANU

A B rie f In tro d u c tio n to th e H is to ry o f C o m p u tin g ANU

A B rie f In tro d u c tio n to th e H is to ry o f C o m p u tin g ANU Faculty of Engineering and IT Department of Computer Science COMP1200 Perspectives on Computing March 2002-5 Chris Johnson In tro to

455 views • 17 slides
New mobile phone algorithms a real world story Steve Babbage Vodafone Group R&D 17

New mobile phone algorithms a real world story Steve Babbage Vodafone Group R&D 17

New mobile phone algorithms a real world story Steve Babbage Vodafone Group R&D 17 February 2011 1 LTE algorithms, for SKEW 2011 C1 - Unrestricted 17 Feb 2011 Vodafone Group R&D Version 1.0 Standards groups 2 LTE algorithms,

585 views • 44 slides
Unit 3 Digital Circuits (Logic) A Brief History COMPUTERS AND SWITCHING TECHNOLOGY 3 4

Unit 3 Digital Circuits (Logic) A Brief History COMPUTERS AND SWITCHING TECHNOLOGY 3 4

1 2 Unit 3 Digital Circuits (Logic) A Brief History COMPUTERS AND SWITCHING TECHNOLOGY 3 4 Mechanical Computers Electronic Computers Primarily gear-based 1945 - ENIAC was first, fully Two prototypes designed and partially

249 views • 9 slides
AN LLVM INSTRUMENTATION PLUG-IN FOR SCORE-P Performance: an old problem The most constant

AN LLVM INSTRUMENTATION PLUG-IN FOR SCORE-P Performance: an old problem The most constant

AN LLVM INSTRUMENTATION PLUG-IN FOR SCORE-P Performance: an old problem The most constant difficulty in contriving the engine has arisen from the desire to reduce Difference Engine the time in which the calculations were executed to the

363 views • 20 slides
Welcome to the Course Introduction to the Course Hans-Joachim Bckenhauer Dennis Komm Autumn

Welcome to the Course Introduction to the Course Hans-Joachim Bckenhauer Dennis Komm Autumn

Departement Informatik Digital Medicine I Welcome to the Course Introduction to the Course Hans-Joachim Bckenhauer Dennis Komm Autumn 2020 October 1, 2020 Material The Team Lecturers Hans-Joachim Bckenhauer Dennis Komm Lecture

465 views • 13 slides
Data Integration with Ontologies Sebastian Brandt brandt@cs.manchester.ac.uk (slides by Bijan

Data Integration with Ontologies Sebastian Brandt brandt@cs.manchester.ac.uk (slides by Bijan

Data Integration with Ontologies Sebastian Brandt brandt@cs.manchester.ac.uk (slides by Bijan Parsia bparsia@cs.man.ac.uk) 1 Friday, 2 May 2014 Ontology Based Data Access (ODBA) Ontology at run time? More, ontology for the end

147 views • 14 slides
Women In Open Source & Computer Technology Allison Fox - RITlug Secretary Wait, youre a

Women In Open Source & Computer Technology Allison Fox - RITlug Secretary Wait, youre a

Women In Open Source & Computer Technology Allison Fox - RITlug Secretary Wait, youre a business major? Yep. Ada Lovelace OG Computer Programmer Helped program Charles Babbages Difference Engine Tabulated

471 views • 10 slides
ChurchTuring Thesis CSCI 3130 Formal Languages and Automata Theory Siu On CHAN Fall 2018

ChurchTuring Thesis CSCI 3130 Formal Languages and Automata Theory Siu On CHAN Fall 2018

ChurchTuring Thesis CSCI 3130 Formal Languages and Automata Theory Siu On CHAN Fall 2018 Chinese University of Hong Kong 1/20 What is a computer? computer program input output A computer is a machine that manipulates data according to

220 views • 20 slides
eSTREAM Algorithms for the Next Round http://www.ecrypt.eu.org/stream/ 27 March 2007 Matt

eSTREAM Algorithms for the Next Round http://www.ecrypt.eu.org/stream/ 27 March 2007 Matt

eSTREAM Algorithms for the Next Round http://www.ecrypt.eu.org/stream/ 27 March 2007 Matt Robshaw Bart Preneel eSTREAM A multi-year project within ECRYPT to promote research into stream ciphers (2004-2008) The goal of eSTREAM is to

408 views • 6 slides
I ntroduction to Parallel Perform ance Engineering Bert W esarg Technische Universitt Dresden

I ntroduction to Parallel Perform ance Engineering Bert W esarg Technische Universitt Dresden

VIRTUAL INSTITUTE HIGH PRODUCTIVITY SUPERCOMPUTING I ntroduction to Parallel Perform ance Engineering Bert W esarg Technische Universitt Dresden (with content used with permission from tutorials by Bernd Mohr/ JSC and Luiz DeRose/ Cray)

308 views • 28 slides
Different approaches to Talk based on the work made in collaboration with: the global periodicity

Different approaches to Talk based on the work made in collaboration with: the global periodicity

Different approaches to Talk based on the work made in collaboration with: the global periodicity problem Anna Cima (UAB), Armengol Gasull V ctor Ma nosa (UPC), Francesc Ma nosas (UAB), UAB ICDEA 2012, Barcelona Armengol Gasull

220 views • 10 slides
Introduction to Parallel Application Performance Engineering Brian Wylie Jlich Supercomputing

Introduction to Parallel Application Performance Engineering Brian Wylie Jlich Supercomputing

VIRTUAL INSTITUTE HIGH PRODUCTIVITY SUPERCOMPUTING Introduction to Parallel Application Performance Engineering Brian Wylie Jlich Supercomputing Centre (with content used with permission from tutorials by Bernd Mohr/JSC and Luiz

632 views • 28 slides
Preleminary work in Lyon Florent de Dinechin, Nicolas Brunie Introduction Introduction First

Preleminary work in Lyon Florent de Dinechin, Nicolas Brunie Introduction Introduction First

Preleminary work in Lyon Florent de Dinechin, Nicolas Brunie Introduction Introduction First experiment: FloPoCo-like Second experiment: rewriting rules High-level back-end? MLs flow: backend and code generation Conclusion Florent de

500 views • 47 slides
Flexible Timing Simulation of RISC-V Processors with Sniper Neet eethu B Bal al M Mal ally

Flexible Timing Simulation of RISC-V Processors with Sniper Neet eethu B Bal al M Mal ally

Flexible Timing Simulation of RISC-V Processors with Sniper Neet eethu B Bal al M Mal ally lya 1 , Cecilia Gonzalez-Alvarez 2 , Trevor E. Carlson 1 1 National University of Singapore, Singapore 2 Ghent University, Belgium Outline Need

784 views • 28 slides
DU DUNE NE's Hardware Trigger architecture, Su Supern rnova tri rigger Ba Babak k Ab Abi

DU DUNE NE's Hardware Trigger architecture, Su Supern rnova tri rigger Ba Babak k Ab Abi

DU DUNE NE's Hardware Trigger architecture, Su Supern rnova tri rigger Ba Babak k Ab Abi , Ju Justo Ma Martin-Al Albo DUNE DAQ Simulations Meeting 05 05 Ju Jun 2017 2017 1 Mo Motivations We have a outline of physics

289 views • 15 slides
FAWN: A Fast Array of Wimpy Nodes David G. Andersen, Jason Franklin, Michael Kaminsky * , Amar

FAWN: A Fast Array of Wimpy Nodes David G. Andersen, Jason Franklin, Michael Kaminsky * , Amar

FAWN: A Fast Array of Wimpy Nodes David G. Andersen, Jason Franklin, Michael Kaminsky * , Amar Phanishayee, Lawrence Tan, Vijay Vasudevan Carnegie Mellon University, * Intel Labs SOSP09 1 CAS ICT Storage System Group Outline

576 views • 30 slides
Digital System on Chip (SoC) Computer-Aided Design Flow ELEC 4200 Digital Systems Design

Digital System on Chip (SoC) Computer-Aided Design Flow ELEC 4200 Digital Systems Design

Digital System on Chip (SoC) Computer-Aided Design Flow ELEC 4200 Digital Systems Design Victor P . Nelson Progress of State of the Art Year Integration Level # devices Function 1938-46 Electromagnetic relays 1 1943-54 Vacuum

627 views • 16 slides
the rdyncall package A n i m p r o v e d f o r e i g n f u n c t i o n i n t e r f a c e f o

the rdyncall package A n i m p r o v e d f o r e i g n f u n c t i o n i n t e r f a c e f o

the rdyncall package A n i m p r o v e d f o r e i g n f u n c t i o n i n t e r f a c e f o r R Daniel Adler Tassilo Philipp Georg-August Potion Studios Universitt Gttingen Game Development useR! 2009, 9th of July,

1.05k views • 76 slides
Visible Surface Detection (Chapt. 15 in FVD, Chapt. 13 in Hearn & Baker) 1 Given a set

Visible Surface Detection (Chapt. 15 in FVD, Chapt. 13 in Hearn & Baker) 1 Given a set

Visible Surface Detection (Chapt. 15 in FVD, Chapt. 13 in Hearn & Baker) 1 Given a set of 3D objects and a viewing specifications, determine which lines or surfaces of the objects should be visible. A surface might be occluded by

1.13k views • 56 slides
Non Photorealistic Rendering BY DMYTRO TKACHUK COMPUTER GRAPHICS SEMINAR Non photorealistic

Non Photorealistic Rendering BY DMYTRO TKACHUK COMPUTER GRAPHICS SEMINAR Non photorealistic

Non Photorealistic Rendering BY DMYTRO TKACHUK COMPUTER GRAPHICS SEMINAR Non photorealistic rendering Non photorealistic rendering (NPR) is a process by which computer engineers try to animate and represent items inspired by paintings,

593 views • 35 slides

More recommend