synthesis
play

Synthesis A Lock-Free Multiprocessor OS Kernel Josh Triplett April - PowerPoint PPT Presentation

Feb 18, 2024 •123 likes •1.66k views

Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Synthesis A Lock-Free Multiprocessor OS Kernel Josh Triplett April 19, 2006 Locking a Linked List Implementing a Spinlock Atomic

  1. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Problems with disabling software interrupts • More expensive • Queue maintenance • Doesn’t protect against access from hardware interrupts • Still only for short critical sections • Can cause process hangs if not released • Coarse-grained (still only one “lock”) • Still insufficient for multiprocessors • Still need real synchronization

  2. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Problems with disabling software interrupts • More expensive • Queue maintenance • Doesn’t protect against access from hardware interrupts • Still only for short critical sections • Can cause process hangs if not released • Coarse-grained (still only one “lock”) • Still insufficient for multiprocessors • Still need real synchronization

  3. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Problems with disabling software interrupts • More expensive • Queue maintenance • Doesn’t protect against access from hardware interrupts • Still only for short critical sections • Can cause process hangs if not released • Coarse-grained (still only one “lock”) • Still insufficient for multiprocessors • Still need real synchronization

  4. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Problems with disabling software interrupts • More expensive • Queue maintenance • Doesn’t protect against access from hardware interrupts • Still only for short critical sections • Can cause process hangs if not released • Coarse-grained (still only one “lock”) • Still insufficient for multiprocessors • Still need real synchronization

  5. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Problems with disabling software interrupts • More expensive • Queue maintenance • Doesn’t protect against access from hardware interrupts • Still only for short critical sections • Can cause process hangs if not released • Coarse-grained (still only one “lock”) • Still insufficient for multiprocessors • Still need real synchronization

  6. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Problems with disabling software interrupts • More expensive • Queue maintenance • Doesn’t protect against access from hardware interrupts • Still only for short critical sections • Can cause process hangs if not released • Coarse-grained (still only one “lock”) • Still insufficient for multiprocessors • Still need real synchronization

  7. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Busywaiting with a spinlock static DEFINE_SPINLOCK(list_lock); spin_lock(&list_lock); node->next = head; head = node; spin_unlock(&list_lock); • Assumes every thread has a processor • Nothing better to do than wait • Spinning impacts other processors • Variants reduce impact, add queuing overhead

  8. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Busywaiting with a spinlock static DEFINE_SPINLOCK(list_lock); spin_lock(&list_lock); node->next = head; head = node; spin_unlock(&list_lock); • Assumes every thread has a processor • Nothing better to do than wait • Spinning impacts other processors • Variants reduce impact, add queuing overhead

  9. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Busywaiting with a spinlock static DEFINE_SPINLOCK(list_lock); spin_lock(&list_lock); node->next = head; head = node; spin_unlock(&list_lock); • Assumes every thread has a processor • Nothing better to do than wait • Spinning impacts other processors • Variants reduce impact, add queuing overhead

  10. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Busywaiting with a spinlock static DEFINE_SPINLOCK(list_lock); spin_lock(&list_lock); node->next = head; head = node; spin_unlock(&list_lock); • Assumes every thread has a processor • Nothing better to do than wait • Spinning impacts other processors • Variants reduce impact, add queuing overhead

  11. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Busywaiting with a spinlock static DEFINE_SPINLOCK(list_lock); spin_lock(&list_lock); node->next = head; head = node; spin_unlock(&list_lock); • Assumes every thread has a processor • Nothing better to do than wait • Spinning impacts other processors • Variants reduce impact, add queuing overhead

  12. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Busywaiting with a spinlock static DEFINE_SPINLOCK(list_lock); spin_lock(&list_lock); node->next = head; head = node; spin_unlock(&list_lock); • Assumes every thread has a processor • Nothing better to do than wait • Spinning impacts other processors • Variants reduce impact, add queuing overhead

  13. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Busywaiting with a spinlock static DEFINE_SPINLOCK(list_lock); spin_lock(&list_lock); node->next = head; head = node; spin_unlock(&list_lock); • Assumes every thread has a processor • Nothing better to do than wait • Spinning impacts other processors • Variants reduce impact, add queuing overhead

  14. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Busywaiting with a spinlock static DEFINE_SPINLOCK(list_lock); spin_lock(&list_lock); node->next = head; head = node; spin_unlock(&list_lock); • Assumes every thread has a processor • Nothing better to do than wait • Spinning impacts other processors • Variants reduce impact, add queuing overhead

  15. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Busywaiting with a spinlock static DEFINE_SPINLOCK(list_lock); spin_lock(&list_lock); node->next = head; head = node; spin_unlock(&list_lock); • Assumes every thread has a processor • Nothing better to do than wait • Spinning impacts other processors • Variants reduce impact, add queuing overhead

  16. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Blocking with a semaphore static DECLARE_MUTEX(list_lock); while(down_interruptible(&list_lock) == -EINTR) ; node->next = head; head = node; up(&list_lock); • Queuing overhead • Goes through scheduler • Can block

  17. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Blocking with a semaphore static DECLARE_MUTEX(list_lock); while(down_interruptible(&list_lock) == -EINTR) ; node->next = head; head = node; up(&list_lock); • Queuing overhead • Goes through scheduler • Can block

  18. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Blocking with a semaphore static DECLARE_MUTEX(list_lock); while(down_interruptible(&list_lock) == -EINTR) ; node->next = head; head = node; up(&list_lock); • Queuing overhead • Goes through scheduler • Can block

  19. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Blocking with a semaphore static DECLARE_MUTEX(list_lock); while(down_interruptible(&list_lock) == -EINTR) ; node->next = head; head = node; up(&list_lock); • Queuing overhead • Goes through scheduler • Can block

  20. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Blocking with a semaphore static DECLARE_MUTEX(list_lock); while(down_interruptible(&list_lock) == -EINTR) ; node->next = head; head = node; up(&list_lock); • Queuing overhead • Goes through scheduler • Can block

  21. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Blocking with a semaphore static DECLARE_MUTEX(list_lock); while(down_interruptible(&list_lock) == -EINTR) ; node->next = head; head = node; up(&list_lock); • Queuing overhead • Goes through scheduler • Can block

  22. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Blocking with a semaphore static DECLARE_MUTEX(list_lock); while(down_interruptible(&list_lock) == -EINTR) ; node->next = head; head = node; up(&list_lock); • Queuing overhead • Goes through scheduler • Can block

  23. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Blocking with a semaphore static DECLARE_MUTEX(list_lock); while(down_interruptible(&list_lock) == -EINTR) ; node->next = head; head = node; up(&list_lock); • Queuing overhead • Goes through scheduler • Can block

  24. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Potential Correctness Problems with Mutual Exclusion • Deadlocks • Priority Inversion

  25. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Potential Correctness Problems with Mutual Exclusion • Deadlocks • Priority Inversion

  26. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Locking summary • Provides correctness (if used correctly) • Adds overhead • Causes problems • Various different tradeoffs • Alternatives? • Shared data structures need synchronization, right?

  27. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Locking summary • Provides correctness (if used correctly) • Adds overhead • Causes problems • Various different tradeoffs • Alternatives? • Shared data structures need synchronization, right?

  28. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Locking summary • Provides correctness (if used correctly) • Adds overhead • Causes problems • Various different tradeoffs • Alternatives? • Shared data structures need synchronization, right?

  29. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Locking summary • Provides correctness (if used correctly) • Adds overhead • Causes problems • Various different tradeoffs • Alternatives? • Shared data structures need synchronization, right?

  30. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Locking summary • Provides correctness (if used correctly) • Adds overhead • Causes problems • Various different tradeoffs • Alternatives? • Shared data structures need synchronization, right?

  31. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Locking summary • Provides correctness (if used correctly) • Adds overhead • Causes problems • Various different tradeoffs • Alternatives? • Shared data structures need synchronization, right?

  32. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Spinlock implementation A first attempt: void spin_lock(spinlock_t *lock) { while(lock->counter != 0) ; lock->counter = 1; }

  33. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Spinlock implementation A first attempt: void spin_lock(spinlock_t *lock) { while(lock->counter != 0) ; lock->counter = 1; }

  34. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Spinlock implementation A first attempt: void spin_lock(spinlock_t *lock) { while(lock->counter != 0) ; lock->counter = 1; }

  35. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Potential race condition Thread 1 Thread 2 while(lock->counter != 0) ; while(lock->counter != 0) ; lock->counter = 1; lock->counter = 1;

  36. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Potential race condition Thread 1 Thread 2 while(lock->counter != 0) ; while(lock->counter != 0) ; lock->counter = 1; lock->counter = 1;

  37. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Potential race condition Thread 1 Thread 2 while(lock->counter != 0) ; while(lock->counter != 0) ; lock->counter = 1; lock->counter = 1;

  38. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Potential race condition Thread 1 Thread 2 while(lock->counter != 0) ; while(lock->counter != 0) ; lock->counter = 1; lock->counter = 1;

  39. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Potential race condition Thread 1 Thread 2 while(lock->counter != 0) ; while(lock->counter != 0) ; lock->counter = 1; lock->counter = 1;

  40. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Fixing this race condition? • Can’t just disable interrupts: insufficient for multiprocessors • Can’t use semaphores: we don’t want to block

  41. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Fixing this race condition? • Can’t just disable interrupts: insufficient for multiprocessors • Can’t use semaphores: we don’t want to block

  42. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Locking the lock void spin_lock(spinlock_t *lock) { spin_lock(lock->lock); while(lock->counter != 0) ; lock->counter = 1; spin_unlock(lock->lock); }

  43. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Locking the lock void spin_lock(spinlock_t *lock) { spin_lock(lock->lock); while(lock->counter != 0) ; lock->counter = 1; spin_unlock(lock->lock); } Something wrong here!

  44. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Fixing the semaphore • Alternatives? • Shared data structures need synchronization, right?

  45. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Fixing the semaphore • Alternatives? • Shared data structures need synchronization, right?

  46. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Atomic instructions • One instruction, indivisible • Bus locking protocols • No interleaving • What do we have available?

  47. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Atomic instructions • One instruction, indivisible • Bus locking protocols • No interleaving • What do we have available?

  48. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Atomic instructions • One instruction, indivisible • Bus locking protocols • No interleaving • What do we have available?

  49. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Atomic instructions • One instruction, indivisible • Bus locking protocols • No interleaving • What do we have available?

  50. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Test and set • Set value to 1, return previous value void spin_lock(spinlock_t *lock) { while(atomic_test_and_set(lock->counter)) ; }

  51. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Exchange • Swap two values atomically • Can implement test and set with exchange: • Exchange with variable containing 1 • Return variable

  52. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Exchange • Swap two values atomically • Can implement test and set with exchange: • Exchange with variable containing 1 • Return variable

  53. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Exchange • Swap two values atomically • Can implement test and set with exchange: • Exchange with variable containing 1 • Return variable

  54. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Exchange • Swap two values atomically • Can implement test and set with exchange: • Exchange with variable containing 1 • Return variable

  55. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Synchronization from atomic instructions • Fundamental synchronization mechanism • Build synchronization abstractions on them • Build OS data structures on the synchronization abstractions

  56. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Synchronization from atomic instructions • Fundamental synchronization mechanism • Build synchronization abstractions on them • Build OS data structures on the synchronization abstractions

  57. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Synchronization from atomic instructions • Fundamental synchronization mechanism • Build synchronization abstractions on them • Build OS data structures on the synchronization abstractions

  58. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Abstractions? From the Exokernel paper: The exokernel architecture is founded on and motivated by a single, simple, and old observation: the lower the level of a primitive, the more efficiently it can be implemented, and the more latitude it grants to implementors of higher-level abstractions.

  59. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Using atomic instructions directly? • Skip implementing synchronization abstractions • Build OS data structures on atomic instructions

  60. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Using atomic instructions directly? • Skip implementing synchronization abstractions • Build OS data structures on atomic instructions

  61. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Linked list revisited Prepend an element to a linked list: node->next = head; head = node; • What would work here? • Atomic arithmetic doesn’t help • Atomic test and set doesn’t help • Would atomic exchange work?

  62. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Linked list revisited Prepend an element to a linked list: node->next = head; head = node; • What would work here? • Atomic arithmetic doesn’t help • Atomic test and set doesn’t help • Would atomic exchange work?

  63. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Linked list revisited Prepend an element to a linked list: node->next = head; head = node; • What would work here? • Atomic arithmetic doesn’t help • Atomic test and set doesn’t help • Would atomic exchange work?

  64. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Linked list revisited Prepend an element to a linked list: node->next = head; head = node; • What would work here? • Atomic arithmetic doesn’t help • Atomic test and set doesn’t help • Would atomic exchange work?

  65. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Linked list with exchange? node->next = node; atomic_exchange(node->next, head) • This won’t work. • It references two memory operands • Atomic exchange can only handle one memory operand

  66. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Linked list with exchange? node->next = node; atomic_exchange(node->next, head) • This won’t work. • It references two memory operands • Atomic exchange can only handle one memory operand

  67. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Linked list with exchange? node->next = node; atomic_exchange(node->next, head) • This won’t work. • It references two memory operands • Atomic exchange can only handle one memory operand

  68. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Linked list with exchange? node->next = node; atomic_exchange(node->next, head) • This won’t work. • It references two memory operands • Atomic exchange can only handle one memory operand

  69. Locking a Linked List Implementing a Spinlock Atomic Instructions Linked list revisited Synthesis Summary Linked list with exchange? node->next = node; atomic_exchange(node->next, head) • This won’t work. • It references two memory operands • Atomic exchange can only handle one memory operand

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

Synthesis of Ranking Functions and Synthesis of Inductive Invariants and Synthesis of

Synthesis of Ranking Functions and Synthesis of Inductive Invariants and Synthesis of

Synthesis of Ranking Functions and Synthesis of Inductive Invariants and Synthesis of Recurrence Sets via Constraint Solving Andreas Podelski January 17, 2012 1 Program Verification and Constraints Reasoning about program

422 views • 28 slides
Synthesis of Carbon Synthesis of Carbon Nanotubes Nanotubes Polina Shifrina Supervisors: Dr.

Synthesis of Carbon Synthesis of Carbon Nanotubes Nanotubes Polina Shifrina Supervisors: Dr.

Synthesis of Carbon Synthesis of Carbon Nanotubes Nanotubes Polina Shifrina Supervisors: Dr. Stephanie Reich, Heiko Dumlich 12.05.2011 Synthesis of CNT s Synthesis of CNT s Arc Discharge (1991) Laser Ablation (1995) Chemical

414 views • 17 slides
Why Again Logic Synthesis Giovanni De Micheli Why again logic synthesis? Strong

Why Again Logic Synthesis Giovanni De Micheli Why again logic synthesis? Strong

Why Again Logic Synthesis Giovanni De Micheli Why again logic synthesis? Strong intellectual value associated with logic synthesis and optimization Problems are far from being solved Current methods and tools grew out of control

372 views • 24 slides
CTP431- Music and Audio Computing Sound Synthesis Graduate School of Culture Technology KAIST

CTP431- Music and Audio Computing Sound Synthesis Graduate School of Culture Technology KAIST

CTP431- Music and Audio Computing Sound Synthesis Graduate School of Culture Technology KAIST Juhan Nam 1 Outlines Additive Synthesis Subtractive Synthesis Analog synthesizers Singing voice synthesis Nonlinear Synthesis

425 views • 39 slides
Asymmetric Synthesis of -Substituted Allyl Boranes and Their Application in the Synthesis of

Asymmetric Synthesis of -Substituted Allyl Boranes and Their Application in the Synthesis of

Asymmetric Synthesis of -Substituted Allyl Boranes and Their Application in the Synthesis of Iso-agatharesinol Yuang Yu Fang and Varinder K. Aggarwal University of Bristol, UK Angew. Chem. Int. Ed. 2007 , 46 , 359-362 Stephan Elzner January

272 views • 13 slides
Solid Texture Synthesis Solid Texture Synthesis Solid Texture Synthesis from 2D Exemplars from

Solid Texture Synthesis Solid Texture Synthesis Solid Texture Synthesis from 2D Exemplars from

Solid Textures Solid Textures Solid Texture Synthesis Solid Texture Synthesis Solid Texture Synthesis from 2D Exemplars from 2D Exemplars from 2D Exemplars Johannes Kopf, University of Konstanz Chi-Wing Fu, Hong Kong Sc & Tech Daniel

268 views • 10 slides
Chemical Synthesis Techniques Chemical Synthesis Techniques Chemical Synthesis Techniques

Chemical Synthesis Techniques Chemical Synthesis Techniques Chemical Synthesis Techniques

Chemical Synthesis Techniques Chemical Synthesis Techniques Chemical Synthesis Techniques Chemical Synthesis Techniques Thin Films & Variations Electrochemical Deposition Electrochemical Deposition (Electrodeposition, Electroplating)

669 views • 9 slides
From Program Synthesis to Optimal Program . . . Optimal Program Synthesis Logical Interpretation

From Program Synthesis to Optimal Program . . . Optimal Program Synthesis Logical Interpretation

Need for Data . . . Program Synthesis Wave Algorithm for . . . Boolean Logic . . . From Program Synthesis to Optimal Program . . . Optimal Program Synthesis Logical Interpretation . . . A Seemingly Natural . . . Counter-Example to . . .

725 views • 24 slides
Sound Synthesis Graduate School of Culture Technology (GSCT) Juhan Nam 1 Outlines Brief

Sound Synthesis Graduate School of Culture Technology (GSCT) Juhan Nam 1 Outlines Brief

CTP 431 Music and Audio Computing Sound Synthesis Graduate School of Culture Technology (GSCT) Juhan Nam 1 Outlines Brief history of sound synthesis Additive Synthesis Subtractive Synthesis Analog synthesizers Nonlinear

983 views • 36 slides
Texture Synthesis Given a texture, create more CS176: Texture Synthesis All examples from Wei

Texture Synthesis Given a texture, create more CS176: Texture Synthesis All examples from Wei

Texture Synthesis Given a texture, create more CS176: Texture Synthesis All examples from Wei & Levoy CS 176 Winter 2011 CS 176 Winter 2011 1 2 Texture Synthesis Texture Synthesis Dont expect too much And amazing successes All

347 views • 3 slides
The knowledge synthesis How can a review and synthesis be systematic? Fredrik Fernqvist Work

The knowledge synthesis How can a review and synthesis be systematic? Fredrik Fernqvist Work

The knowledge synthesis How can a review and synthesis be systematic? Fredrik Fernqvist Work Science, Business Economics and Environmental Psychology Background The National Food Strategy for Sweden Formas Special call (2017): Syntheses

771 views • 20 slides
Synthesis, Verification, and Synthesis, Verification, and Inductive Learning Inductive Learning

Synthesis, Verification, and Synthesis, Verification, and Inductive Learning Inductive Learning

Synthesis, Verification, and Synthesis, Verification, and Inductive Learning Inductive Learning Sanjit A. Seshia EECS Department UC Berkeley Joint work with Susmit Jha (UTC) Dagstuhl Seminar Verified SW Working Group August 2014 July

661 views • 28 slides
Verification and Synthesis of Reactive Programs Overview of System Synthesis. Amir Pnueli

Verification and Synthesis of Reactive Programs Overview of System Synthesis. Amir Pnueli

Lecture 1: Overview of System Synthesis A. Pnueli Lectures Outline Verification and Synthesis of Reactive Programs Overview of System Synthesis. Amir Pnueli Fair Discrete Systems and their Computations. Model Checking Invariance and

309 views • 19 slides
Post-Synthesis Simulation VITAL Models, SDF Files, Timing Simulation Post-synthesis simulation

Post-Synthesis Simulation VITAL Models, SDF Files, Timing Simulation Post-synthesis simulation

Post-Synthesis Simulation VITAL Models, SDF Files, Timing Simulation Post-synthesis simulation Purpose: Verify correctness of synthesized circuit Verify synthesis tool delay/timing estimates Synthesis tool generates: Gate-level

363 views • 18 slides
A Reduction Pathway in the Synthesis A Reduction Pathway in the Synthesis of PbSe Nanocrystal

A Reduction Pathway in the Synthesis A Reduction Pathway in the Synthesis of PbSe Nanocrystal

A Reduction Pathway in the Synthesis A Reduction Pathway in the Synthesis of PbSe Nanocrystal Quantum Dots y Jin Joo, 1 Jeffrey M. Pietryga, 2 John A. McGuire, 2 Sea-Ho Jeon, 2 Darrick J. Williams, 2 Hsing-Lin Wang, 2 and Victor I. Klimov* ,2 1

136 views • 9 slides
Text-to-Speech Synthesis Bernd Mbius Language Science and Technology Saarland University

Text-to-Speech Synthesis Bernd Mbius Language Science and Technology Saarland University

Text-to-Speech Synthesis Bernd Mbius Language Science and Technology Saarland University Lecture 3 May 28, 2020 Formant Synthesis B Mbius Formant synthesis 1 l Formant synthesis acoustic-parametric synthesis method modeling

572 views • 22 slides
FRICTION-FREE BUG REPORTING SPEND TIME WHERE IT MATTERS GAME DEV BUGS EXPECTED WORKFLOW Crash

FRICTION-FREE BUG REPORTING SPEND TIME WHERE IT MATTERS GAME DEV BUGS EXPECTED WORKFLOW Crash

Raphal Saint-Pierre, Tools Team Leader Ubisoft FRICTION-FREE BUG REPORTING SPEND TIME WHERE IT MATTERS GAME DEV BUGS EXPECTED WORKFLOW Crash Fix Close REAL WORKFLOW Crash Callstack Memdump Screenshot Duplicates ? Send bug to

369 views • 34 slides
Netlify Provider The Netlify provider allows you to provision and deploy netlify sites and manage

Netlify Provider The Netlify provider allows you to provision and deploy netlify sites and manage

Netlify Provider The Netlify provider allows you to provision and deploy netlify sites and manage webhooks. The provider needs to be congured with the proper credentials before it can be used. Use the navigation to the left to read about the

277 views • 5 slides
CS260: Object Oriented Programming Some Vocab - October 20, 2016 Overview Quiz next Thursday...

CS260: Object Oriented Programming Some Vocab - October 20, 2016 Overview Quiz next Thursday...

CS260: Object Oriented Programming Some Vocab - October 20, 2016 Overview Quiz next Thursday... Quiz next Thursday... 1. Java Bytecode a. Portable machine code created by an interpreter b. Can be understood and run by any compatible

395 views • 6 slides
Presentations Power Grid TCIP: Trustworthy Cyber Infrastructure for Power Quantitative &

Presentations Power Grid TCIP: Trustworthy Cyber Infrastructure for Power Quantitative &

Trustworthy Cyber Infrastructure for the Presentations Power Grid TCIP: Trustworthy Cyber Infrastructure for Power Quantitative & Qualitative Evaluation Presented by David Nicol TCIP Year 1 Review, December 11, 2006 University of

274 views • 13 slides
Sandboxing 1 logistics CHALLENGE assignment take-home portion of the fjnal next class

Sandboxing 1 logistics CHALLENGE assignment take-home portion of the fjnal next class

Sandboxing 1 logistics CHALLENGE assignment take-home portion of the fjnal next class fjnal exam review 2 CHALLENGE (1) expect to release before Saturday; due by written fjnal probably complete all but two fjve of seven or four of

848 views • 66 slides
Software Engineering I (02161) Week 5 Assoc. Prof. Hubert Baumeister DTU Compute Technical

Software Engineering I (02161) Week 5 Assoc. Prof. Hubert Baumeister DTU Compute Technical

Software Engineering I (02161) Week 5 Assoc. Prof. Hubert Baumeister DTU Compute Technical University of Denmark Spring 2013 Contents Refactoring Refactoring Example Class Diagrams Summary Refactoring Restructure the program without

530 views • 38 slides
Ahead of the Pack: Developing Middle Management from an Inside Perspective Mary Lecy, Hospital

Ahead of the Pack: Developing Middle Management from an Inside Perspective Mary Lecy, Hospital

4/23/2014 Ahead of the Pack: Developing Middle Management from an Inside Perspective Mary Lecy, Hospital Administrator, BluePearl Veterinary Partners 1 4/23/2014 MANAGER LEADER Motivates and Inspires Plans and budgets

518 views • 14 slides
Learning the Valuations of a k-demand Agent Hanrui Zhang Vincent Conitzer Duke

Learning the Valuations of a k-demand Agent Hanrui Zhang Vincent Conitzer Duke

Learning the Valuations of a k-demand Agent Hanrui Zhang Vincent Conitzer Duke University this talk: optimal (up to lower order terms) algorithm for actively learning the valuations of a k- demand agent algorithm with

574 views • 34 slides

More recommend