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

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
Sound Synthesis (Part 2) Graduate School of Culture Technology, KAIST Juhan Nam Category of

Sound Synthesis (Part 2) Graduate School of Culture Technology, KAIST Juhan Nam Category of

2018 Fall CTP431: Music and Audio Computing Sound Synthesis (Part 2) Graduate School of Culture Technology, KAIST Juhan Nam Category of Sound Synthesis Signal Models - Abstract sound synthesis Additive Synthesis Subtractive

803 views • 19 slides
Starting a Custom Synthesis Company Ron Bihovsky Key Synthesis LLC Education and Experience

Starting a Custom Synthesis Company Ron Bihovsky Key Synthesis LLC Education and Experience

Starting a Custom Synthesis Company Ron Bihovsky Key Synthesis LLC Education and Experience PhD, UC Berkeley, Organic Chemistry 1977 Postdoctoral Fellow, UW Madison 1978 - 1980 Assistant Professor, SUNY Stony Brook 1980 - 1987

634 views • 18 slides
ABSTRACT ABSTRACT Microwave induced synthesis has various advantages over conventional synthesis,

ABSTRACT ABSTRACT Microwave induced synthesis has various advantages over conventional synthesis,

Microwave-assisted Facile Synthesis And Anticancer Evaluation Of N-((5-(substituted Methylene Amino)- 1,3,4-thiadiazol-2-yl)methyl) Benzamide Derivatives Anna Pratima Nikalje*, Shailee Tiwari, Sumaiya Siddiqui, Y. B. CHAVAN COLLEGE OF

587 views • 31 slides
Text-to-Image Generation Yu Cheng Text-to-Image Synthesis Text-to-Image Synthesis

Text-to-Image Generation Yu Cheng Text-to-Image Synthesis Text-to-Image Synthesis

Text-to-Image Generation Yu Cheng Text-to-Image Synthesis Text-to-Image Synthesis StackGAN, AttnGAN, TAGAN, ObjGAN Text-to-Video Synthesis GAN-based methods, VAE-based methods, StoryGAN Dialogue-based Image Synthesis

827 views • 45 slides
Co-synthesis techniques for embedded systems embedded systems Kelvin Yuk June 5, 2002 EEC282 -

Co-synthesis techniques for embedded systems embedded systems Kelvin Yuk June 5, 2002 EEC282 -

Co-synthesis techniques for embedded systems embedded systems Kelvin Yuk June 5, 2002 EEC282 - Akella Introduction Co-synthesis of high-level systems Approaches to co-synthesis 1. Architectural Co-synthesis Algorithm 2. Process

257 views • 10 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 4 June 4, 2020 Diphone Synthesis B Mbius Concatenative synthesis l Concatenative synthesis: general procedure Data-based,

611 views • 27 slides
Hardware Design with VHDL Synthesis of VHDL Code ECE 443 Synthesis of VHDL Code This slide set

Hardware Design with VHDL Synthesis of VHDL Code ECE 443 Synthesis of VHDL Code This slide set

Hardware Design with VHDL Synthesis of VHDL Code ECE 443 Synthesis of VHDL Code This slide set covers Fundamental limitation of EDA software Realization of VHDL operator Realization of VHDL data type VHDL synthesis flow

511 views • 34 slides
Guided Reactive Synthesis with Soft Requirements Reactive Synthesis from QDDC Specify the

Guided Reactive Synthesis with Soft Requirements Reactive Synthesis from QDDC Specify the

Guided Reactive Synthesis with Soft Requirements Reactive Synthesis from QDDC Specify the input-output behaviour in a high-level language e.g. a temporal logic (QDDC) Problem Statement : Given an interface definition and temporal spec

434 views • 18 slides

More recommend