+ All Categories
Home > Documents > Concurrency) - University of...

Concurrency) - University of...

Date post: 25-Mar-2020
Category:

Documents
Upload: others
View: 0 times
Download: 0 times
Download Report this document
Share this document with a friend
32
Concurrency
Transcript
Page 1: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Concurrency  

Page 2: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Mo+va+on  

•  Opera+ng  systems  (and  applica+on  programs)  o9en  need  to  be  able  to  handle  mul+ple  things  happening  at  the  same  +me  – Process  execu+on,  interrupts,  background  tasks,  system  maintenance    

•  Humans  are  not  very  good  at  keeping  track  of  mul+ple  things  happening  simultaneously  

•  Threads  are  an  abstrac+on  to  help  bridge  this  gap  

Page 3: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Why  Concurrency?  

•  Servers  – Mul+ple  connec+ons  handled  simultaneously  

•  Parallel  programs  – To  achieve  beFer  performance  

•  Programs  with  user  interfaces  – To  achieve  user  responsiveness  while  doing  computa+on  

•  Network  and  disk  bound  programs  – To  hide  network/disk  latency  

Page 4: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Déjà  vu?  

•  Didn’t  we  learn  all  about  concurrency  in  CSE  332/333?  – More  prac+ce  

•  Realis+c  examples,  especially  in  the  project  

– Design  paFerns  and  piSalls  •  Methodology  for  wri+ng  correct  concurrent  code  

–  Implementa+on  •  How  do  threads  work  at  the  machine  level?  

– CPU  scheduling  •  If  mul+ple  threads  to  run,  which  do  we  do  first?  

Page 5: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Defini+ons  

•  A  thread  is  a  single  execu+on  sequence  that  represents  a  separately  schedulable  task  – Single  execu+on  sequence:  familiar  programming  model  

– Separately  schedulable:  OS  can  run  or  suspend  a  thread  at  any  +me  

•  Protec+on  is  an  orthogonal  concept  – Can  have  one  or  many  threads  per  protec+on  domain  

Page 6: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Threads  in  the  Kernel  and  at  User-­‐Level  

•  Mul+-­‐threaded  kernel  – mul+ple  threads,  sharing  kernel  data  structures,  capable  of  using  privileged  instruc+ons  

– OS/161  assignment  1  •  Mul+process  kernel  – Mul+ple  single-­‐threaded  processes  –  System  calls  access  shared  kernel  data  structures  – OS/161  assignment  2  

•  Mul+-­‐threaded  user  program  – mul+ple  threads,  sharing  same  data  structures,  isolated  from  other  user  programs  

•  Mul+ple  mul+-­‐threaded  processes  

Page 7: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Thread  Abstrac+on  •  Infinite  number  of  processors  •  Threads  execute  with  variable  speed  – Programs  must  be  designed  to  work  with  any  schedule  

Programmer Abstraction Physical Reality

Threads

Processors 1 2 3 4 5 1 2

RunningThreads

Ready Threads

Page 8: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Programmer  vs.  Processor  View  

Programmer·s View

.

.

.x = x + 1 ;y = y + x ;z = x + 5 y ;

.

.

.

Possible Execution

#1...

x = x + 1 ;y = y + x ;z = x + 5 y ;

.

.

.

Possible Execution

#2...

x = x + 1 ;. . . . . . . . . . . . . .

Thread is suspended.Other thread(s) run.Thread is resumed.. . . . . . . . . . . . . . .y = y + x ;z = x + 5 y ;

Possible Execution

#3...

x = x + 1 ;y = y + x ;

. . . . . . . . . . . . . . .Thread is suspended.Other thread(s) run.Thread is resumed.. . . . . . . . . . . . . . . .

z = x + 5 y ;

Page 9: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Possible  Execu+ons  

Thread 1

Thread 2

Thread 3

One Execution Another Execution

Thread 1

Thread 2

Thread 3

Another Execution

Thread 1

Thread 2

Thread 3

Page 10: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Thread  Opera+ons  

•  thread_create(thread,  func,  args)  –  Create  a  new  thread  to  run  func(args)  –  OS/161:  thread_fork  

•  thread_yield()  –  Relinquish  processor  voluntarily  –  OS/161:  thread_yield  

•  thread_join(thread)  –  In  parent,  wait  for  forked  thread  to  exit,  then  return  –  OS/161:  assignment  1  

•  thread_exit  –  Quit  thread  and  clean  up,  wake  up  joiner  if  any  –  OS/161:  thread_exit  

Page 11: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Example:  threadHello  #define  NTHREADS  10  thread_t  threads[NTHREADS];  main()  {          for  (i  =  0;  i  <  NTHREADS;  i++)    thread_create(&threads[i],  &go,  i);          for  (i  =  0;  i  <  NTHREADS;  i++)  {                  exitValue  =  thread_join(threads[i]);                  prinS("Thread  %d  returned  with  %ld\n",  i,  exitValue);          }          prinS("Main  thread  done.\n");  }  void  go  (int  n)  {          prinS("Hello  from  thread  %d\n",  n);          thread_exit(100  +  n);          //  REACHED?  }  

Page 12: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

threadHello:  Example  Output  

•  Why  must  “thread  returned”  print  in  order?  

•  What  is  maximum  #  of  threads  running  when  thread  5  prints  hello?  

•  Minimum?  

Page 13: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Fork/Join  Concurrency  

•  Threads  can  create  children,  and  wait  for  their  comple+on  

•  Data  only  shared  before  fork/a9er  join  •  Examples:  – Web  server:  fork  a  new  thread  for  every  new  connec+on  •  As  long  as  the  threads  are  completely  independent  

– Merge  sort  – Parallel  memory  copy  

Page 14: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

bzero  with  fork/join  concurrency  void  blockzero  (unsigned  char  *p,  int  length)  {          int  i,  j;          thread_t  threads[NTHREADS];          struct  bzeroparams  params[NTHREADS];  

//  For  simplicity,  assumes  length  is  divisible  by  NTHREADS.  for  (i  =  0,  j  =  0;  i  <  NTHREADS;  i++,  j  +=  length/NTHREADS)  {                  params[i].buffer  =  p  +  i  *  length/NTHREADS;                  params[i].length  =  length/NTHREADS;                  thread_create_p(&(threads[i]),  &go,  &params[i]);          }          for  (i  =  0;  i  <  NTHREADS;  i++)  {                  thread_join(threads[i]);          }  }  

Page 15: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Thread  Data  Structures  Thread 1·s

Perï7hread State

Stack

Thread �·sPerï7hread State

SharedState

ThreadMetadata

SavedRegisters

StackInformation

Thread ControlBlock (TCB)

Stack

ThreadMetadata

SavedRegisters

StackInformation

Thread ControlBlock (TCB)

GlobalVariables

Heap

Code

Page 16: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Thread  Lifecycle  

Thread Creation

s thread_create( )

SchedulerResumes Thread

Thread Exit

s t h r e a d _ e x i t ( )Thread Yield/Scheduler

Suspends Threads t h r e a d _ y i e l d ( )

Thread Waits for Events t h r e a d _ j o i n ( )

Event Occurs0ther Thread Calls

s t h r e a d _ j o i n ( )

Init Ready

Waiting

Running Finished

Page 17: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Implemen+ng  Threads:  Roadmap  

•  Kernel  threads  – Thread  abstrac+on  only  available  to  kernel  – To  the  kernel,  a  kernel  thread  and  a  single  threaded  user  process  look  quite  similar  

•  Mul+threaded  processes  using  kernel  threads  (Linux,  MacOS)  – Kernel  thread  opera+ons  available  via  syscall  

•  User-­‐level  threads  – Thread  opera+ons  without  system  calls  

Page 18: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Mul+threaded  OS  Kernel  

Kernel

User-Level Processes

Heap

Code

Globals TCB 1

Kernel Thread 1

Stack

TCB 2

Kernel Thread 2

Stack

TCB 3

Kernel Thread 3

Stack Stack Stack

PCB 1

Process 1

PCB 2

Process 2

Heap

Code

Globals

Stack

Process 1Thread

Heap

Code

Globals

Stack

Process 2Thread

Page 19: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Implemen+ng  threads  

•  Thread_fork(func,  args)  – Allocate  thread  control  block  – Allocate  stack  –  Build  stack  frame  for  base  of  stack  (stub)  –  Put  func,  args  on  stack  –  Put  thread  on  ready  list  – Will  run  some+me  later  (maybe  right  away!)  

•  stub(func,  args):  OS/161  mips_threadstart  –  Call  (*func)(args)  –  If  return,  call  thread_exit()  

Page 20: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Thread  Stack  

•  What  if  a  thread  puts  too  many  procedures  on  its  stack?  – What  happens  in  Java?  – What  happens  in  the  Linux  kernel?  – What  happens  in  OS/161?  

– What  should  happen?  

Page 21: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Thread  Context  Switch  

•  Voluntary  – Thread_yield  – Thread_join  (if  child  is  not  done  yet)  

•  Involuntary  –  Interrupt  or  excep+on  – Some  other  thread  is  higher  priority  

Page 22: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Voluntary  thread  context  switch  

•  Save  registers  on  old  stack  •  Switch  to  new  stack,  new  thread  •  Restore  registers  from  new  stack  •  Return  •  Exactly  the  same  with  kernel  threads  or  user  threads  – OS/161:  thread  switch  is  always  between  kernel  threads,  not  between  user  process  and  kernel  thread  

Page 23: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

OS/161  switchframe_switch  /*  a0:  old  thread  stack  pointer      *  a1:  new  thread  stack  pointer  */  

/*  Allocate  stack  space  for  10  registers.  */        addi  sp,  sp,  -­‐40  

     /*  Save  the  registers  */        sw      ra,  36(sp)        sw      gp,  32(sp)        sw      s8,  28(sp)        sw      s6,  24(sp)        sw      s5,  20(sp)        sw      s4,  16(sp)        sw      s3,  12(sp)        sw      s2,  8(sp)        sw      s1,  4(sp)        sw      s0,  0(sp)  

     /*  Store  old  stack  pointer  in  old  thread  */        sw      sp,  0(a0)  

 /*  Get  new  stack  pointer  from  new  thread  */        lw      sp,  0(a1)        nop                      /*  delay  slot  for  load  */  

/*  Now,  restore  the  registers  */        lw      s0,  0(sp)        lw      s1,  4(sp)        lw      s2,  8(sp)        lw      s3,  12(sp)        lw      s4,  16(sp)        lw      s5,  20(sp)        lw      s6,  24(sp)        lw      s8,  28(sp)        lw      gp,  32(sp)        lw      ra,  36(sp)        nop                                    /*  delay  slot  for  load  */  

     /*  and  return.  */        j  ra        addi  sp,  sp,  40            /*  in  delay  slot  */  

Page 24: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

x86  switch_threads  (oldT,  nextT)  #  Save  caller’s  register  state  #    NOTE:  %eax,  etc.  are  ephemeral  pushl  %ebx  pushl  %ebp  pushl  %esi  pushl  %edi  

#  Get  offsetof  (struct  thread,  stack)  mov  thread_stack_ofs,  %edx  #  Save  current  stack  pointer  to  old  

thread's  stack,  if  any.  movl  SWITCH_CUR(%esp),  %eax  movl  %esp,  (%eax,%edx,1)  

#  Change  stack  pointer  to  new  thread's  stack  

#  this  also  changes  currentThread  movl  SWITCH_NEXT(%esp),  %ecx  movl  (%ecx,%edx,1),  %esp  

#  Restore  caller's  register  state.  popl  %edi  popl  %esi  popl  %ebp  popl  %ebx  ret  

Page 25: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

A  Subtlety  

•  Thread_create  puts  new  thread  on  ready  list  •  When  it  first  runs,  some  thread  calls  switchframe  – Saves  old  thread  state  to  stack  – Restores  new  thread  state  from  stack  

•  Set  up  new  thread’s  stack  as  if  it  had  saved  its  state  in  switchframe  – “returns”  to  stub  at  base  of  stack  to  run  func  

Page 26: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Two  Threads  Call  Yield  

164 Chapter 4 Concurrency and Threads

Logical View

Thread 1 Thread 2go(){ go(){

while(1){ while(1){thread_yield(); thread_yield();

} }} }

Physical Reality

Thread 1’s instructions Thread 2’s instructions Processor’s instructions“return” from thread_switch “return” from thread_switch

into stub into stubcall go call gocall thread_yield call thread_yieldchoose another thread choose another threadcall thread_switch call thread_switchsave thread 1 state to TCB save thread 1 state to TCBload thread 2 state load thread 2 state

“return” from thread_switch “return” from thread_switchinto stub into stub

call go call gocall thread_yield call thread_yieldchoose another thread choose another threadcall thread_switch call thread_switchsave thread 2 state to TCB save thread 2 state to TCBload thread 1 state load thread 1 state

return from thread_switch return from thread_switchreturn from thread_yield return from thread_yieldcall thread_yield call thread_yieldchoose another thread choose another threadcall thread_switch call thread_switchsave thread 1 state to TCB save thread 1 state to TCBload thread 2 state load thread 2 state

return from thread_switch return from thread_switchreturn from thread_yield return from thread_yieldcall thread_yield call thread_yieldchoose another thread choose another threadcall thread_switch call thread_switchsave thread 2 state to TCB save thread 2 state to TCBload thread 1 state load thread 1 state

return from thread_switch return from thread_switchreturn from thread_yield return from thread_yield... ... ...

Figure 4.15: Interleaving of instructions when two threads loop and call thread_yield().

Page 27: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Involuntary  Thread  Switch  

•  Timer  or  I/O  interrupt  – Tells  OS  some  other  thread  should  run  

•  Simple  version  (OS/161)  – End  of  interrupt  handler  calls  schedule()  – When  resumed,  return  from  handler  resumes  kernel  thread  or  user  process  

•  Faster  version  (Linux)  –  Interrupt  handler  returns  to  saved  state  in  TCB  – Could  be  kernel  thread  or  user  process  

Page 28: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Mul+threaded  User  Processes  (Take  1)  

•  User  thread  =  kernel  thread  (Linux,  MacOS)  – System  calls  for  thread  fork,  join,  exit  (and  lock,  unlock,…)  

– Kernel  does  context  switch  – Simple,  but  a  lot  of  transi+ons  between  user  and  kernel  mode  

Page 29: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Mul+threaded  User  Processes  (Take  1)  

Kernel

User-Level Processes

Heap

Code

Globals TCB 1

Kernel Thread 1

Stack

TCB 2

Kernel Thread 2

Stack

TCB 3

Kernel Thread 3

Stack

TCB 1.B

Stack

TCB 1.A

Stack

Process 1

PCB 1

TCB 2.B

Stack

TCB 2.A

Stack

Process 2

PCB 2

Heap

Code

Globals

Stack

Thread A

Stack

Thread BProcess 2

Heap

Code

Globals

Stack

Thread A

Stack

Thread BProcess 1

Page 30: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Mul+threaded  User  Processes  (Take  2)  

•  Green  threads  (early  Java)  – User-­‐level  library,  within  a  single-­‐threaded  process  – Library  does  thread  context  switch  – Preemp+on  via  upcall/UNIX  signal  on  +mer  interrupt  

– Use  mul+ple  processes  for  parallelism  •  Shared  memory  region  mapped  into  each  process  

Page 31: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Mul+threaded  User  Processes  (Take  3)  

•  Scheduler  ac+va+ons  (Windows  8)  – Kernel  allocates  processors  to  user-­‐level  library  – Thread  library  implements  context  switch  – Thread  library  decides  what  thread  to  run  next  

•  Upcall  whenever  kernel  ac+on  requires  (user-­‐level)  scheduling  decision  •  Process  assigned  a  new  processor  •  Processor  removed  from  process  •  System  call  blocks  in  kernel  

Page 32: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)

Ques+on  

•  Compare  event-­‐driven  programming  with  mul+threaded  concurrency.    Which  is  beFer  in  which  circumstances,  and  why?  


Recommended
Class java.lang.Threadpeople.cs.aau.dk/~torp/Teaching/E03/OOP/handouts/concurrency.pdf · OOP: Concurrency 2 Thread • Definition: A thread is a single sequential flow of control

Class java.lang.Threadpeople.cs.aau.dk/~torp/Teaching/E03/OOP/handouts/concurrency.pdf · OOP: Concurrency 2 Thread • Definition: A thread is a single sequential flow of control

Documents

Software Experiment 2 - AndroBenchcsl.skku.edu/uploads/SWE2007F17/7-concurrency.pdf · With your own code, make process-based echo server •At the same time, multiple client can

Software Experiment 2 - AndroBenchcsl.skku.edu/uploads/SWE2007F17/7-concurrency.pdf · With your own code, make process-based echo server •At the same time, multiple client can

Documents

Concurrency, Races & Synchronizationchinetti.me/classes/cs450/lee-site/assets/slides-concurrency.pdf- Concurrent programming with semaphores. Computer Science Science §Concurrency:

Concurrency, Races & Synchronizationchinetti.me/classes/cs450/lee-site/assets/slides-concurrency.pdf- Concurrent programming with semaphores. Computer Science Science §Concurrency:

Documents

CSE590’V’:’Mul-.View’ Reconstruc-on ’’ · Mo-vaon’ • ReconstructSurfaces’thatdo’nothave’supportin’the’ input3d’pointcloud’(low’textured’walls,’windows)’

CSE590’V’:’Mul-.View’ Reconstruc-on ’’ · Mo-vaon’ • ReconstructSurfaces’thatdo’nothave’supportin’the’ input3d’pointcloud’(low’textured’walls,’windows)’

Documents

Concurrency Controlcs.brown.edu/courses/cs127/static/files/slides/concurrency.pdf · protocol. 45 Prevent P(S) cycles from occurring using a concurrency control manager: ensures interleaving

Concurrency Controlcs.brown.edu/courses/cs127/static/files/slides/concurrency.pdf · protocol. 45 Prevent P(S) cycles from occurring using a concurrency control manager: ensures interleaving

Documents

Real Time Operating Systems and Middlewaredisi.unitn.it/~abeni/RTOS/2011/concurrency.pdf · 2010. 10. 22. · ⇒ when a process dies, all its zombies are eliminated A process can

Real Time Operating Systems and Middlewaredisi.unitn.it/~abeni/RTOS/2011/concurrency.pdf · 2010. 10. 22. · ⇒ when a process dies, all its zombies are eliminated A process can

Documents

Perl 6 Concurrency - Jonathan Worthingtonjnthn.net/papers/2019-perlcon-concurrency.pdf · The current model 350+ modules A YAML file for each. Totals over 100,000 lines of YAML. Nearly

Perl 6 Concurrency - Jonathan Worthingtonjnthn.net/papers/2019-perlcon-concurrency.pdf · The current model 350+ modules A YAML file for each. Totals over 100,000 lines of YAML. Nearly

Documents

AOP: Does it Make Sense? The Case of Concurrency and Failuresbriot/cours/AOP-not-for-concurrency.pdf · Aspect-oriented programming, abstraction, objects, concurrency, failures, exceptions,

AOP: Does it Make Sense? The Case of Concurrency and Failuresbriot/cours/AOP-not-for-concurrency.pdf · Aspect-oriented programming, abstraction, objects, concurrency, failures, exceptions,

Documents

Concurrent Concurrency • things happen at the same time ...popl/nykyinen/lecture-slides-pdf-2016/12-concurrency.pdf · Threads (Java) • Concurrency is enabled by – inheriting

Concurrent Concurrency • things happen at the same time ...popl/nykyinen/lecture-slides-pdf-2016/12-concurrency.pdf · Threads (Java) • Concurrency is enabled by – inheriting

Documents

CSE 440: Introduction to HCI - courses.cs.washington.educourses.cs.washington.edu/courses/cse440/14au/slides/lecture/l13...CSE 440: Introduction to HCI User Interface Design, Prototyping,

CSE 440: Introduction to HCI - courses.cs.washington.educourses.cs.washington.edu/courses/cse440/14au/slides/lecture/l13...CSE 440: Introduction to HCI User Interface Design, Prototyping,

Documents

WiSync:(An(Architecture(for(( Fast(Synchroniza5on(through(( …iacoma.cs.uiuc.edu/iacoma-papers/PRES/present_asplos16_2.pdf · Mo$vaon! 4/21/16! WiSync(–ASPLOS(’16(–April(4

WiSync:(An(Architecture(for(( Fast(Synchroniza5on(through(( …iacoma.cs.uiuc.edu/iacoma-papers/PRES/present_asplos16_2.pdf · Mo$vaon! 4/21/16! WiSync(–ASPLOS(’16(–April(4

Documents

Computer-Aided Reasoning for Software CSE507courses.cs.washington.edu/courses/cse507/14au/slides/L4.pdf10K 100K 1,000K 10,000K 1995 1999 2003 2007 2011 2015 Bounded Model Checking.

Computer-Aided Reasoning for Software CSE507courses.cs.washington.edu/courses/cse507/14au/slides/L4.pdf10K 100K 1,000K 10,000K 1995 1999 2003 2007 2011 2015 Bounded Model Checking.

Documents

Modélisa)on Mul)-échelle: Modélisa)on des Macromolécules ...alpha.univ-mlv.fr/M2/cours4.pdf · Résumé des cours 1, 2 et 3 • Modélisaon: Mo;vaon • Visualisaon des protéines

Modélisa)on Mul)-échelle: Modélisa)on des Macromolécules ...alpha.univ-mlv.fr/M2/cours4.pdf · Résumé des cours 1, 2 et 3 • Modélisaon: Mo;vaon • Visualisaon des protéines

Documents

Concurrency in Biological Modeling: Behavior, Execution .../yaki/concurrency.pdf · Concurrency in Biological Modeling: Behavior, Execution and Visualization David Harel a,1,2 Yaki

Concurrency in Biological Modeling: Behavior, Execution .../yaki/concurrency.pdf · Concurrency in Biological Modeling: Behavior, Execution and Visualization David Harel a,1,2 Yaki

Documents

Probabilis#c’ Graphical’ Models’ Introduc#on’ Mo#vaon’ …spark-university.s3.amazonaws.com/stanford-pgm/slides/1.1.1-Intro... · Medical Diagnosis - Thanks to: Eric Horvitz,

Probabilis#c’ Graphical’ Models’ Introduc#on’ Mo#vaon’ …spark-university.s3.amazonaws.com/stanford-pgm/slides/1.1.1-Intro... · Medical Diagnosis - Thanks to: Eric Horvitz,

Documents

Cours de Programmation Avancée - L3 ENS Paris Saclaygc/slides/concurrency.pdf · the Coro module in Perl). 2 OS threads are nearly always preemptive since on a cooperative OS all

Cours de Programmation Avancée - L3 ENS Paris Saclaygc/slides/concurrency.pdf · the Coro module in Perl). 2 OS threads are nearly always preemptive since on a cooperative OS all

Documents

Concurrent programming in C++11 - gsd.web.elte.hugsd.web.elte.hu/lectures/multi/slides/concurrency.pdf · Zoltán Porkoláb: C++11/14 1 Concurrent programming in C++11 Multithreading

Concurrent programming in C++11 - gsd.web.elte.hugsd.web.elte.hu/lectures/multi/slides/concurrency.pdf · Zoltán Porkoláb: C++11/14 1 Concurrent programming in C++11 Multithreading

Documents

ArMOR:Defending AgainstMemory& Consistency&Model ... · Lus$g&etal.,&“ArMOR:&Defending&AgainstMCMMismatches…”& 2 Mo$vaon:&MCMs&Are&S$ll&Difficult!& • Are&memory&consistency&models&(MCMs)&asolved&

ArMOR:Defending AgainstMemory& Consistency&Model ... · Lus$g&etal.,&“ArMOR:&Defending&AgainstMCMMismatches…”& 2 Mo$vaon:&MCMs&Are&S$ll&Difficult!& • Are&memory&consistency&models&(MCMs)&asolved&

Documents