Microsoft Research Cambridge

Transcription

1 Microsoft Research Cambridge Satnam Singh Researcher 18 November 2008

2 Overview Why Microsoft Research? Worldwide Cambridge (MSRC) What are we doing? Research Directions Selected Projects

3 Overview Microsoft Research Worldwide Cambridge (MSRC) What are we doing Research Directions Selected Projects

4 Cambridge Worldwide Microsoft Research Labs Researchers External Research Groups Technology Learning Labs Collaborative Institutes and Centers

5 Microsoft Research Mission Advance the state of the art in our chosen areas of computer science Making computers easier to use Reducing the cost of computing Making software developers more productive Transfer the resulting technology to Microsoft businesses Ensure Microsoft has a future Provide corporate agility - rapid response to change New technologies New competitors New business models Reservoir of technology Pool of expertise and smart people And for MSR Cambridge be Microsoft s leading technical asset in the region

6 Inventing the Future Computing Platform Trustworthy Software Data and Documents User Interfaces and Social Computing Science and Computing Intelligent Computing Operating Systems Languages Databases Multi-modal Interfaces Bioinformatics Machine Learning Networking Security Search Collaboration Quantum Computing Artificial Intelligence Mobile Devices Compilers Media Social Networks Highperformance Computing Data Analysis

7 Microsoft Research Cambridge The Leadership Team Founded in 1997 as first non-us based Microsoft Andrew Herbert Managing Director Research lab Chris Bishop Chief Research Scientist Partnership with leading European Universities Ken Wood Deputy Managing Director Partners with innovation centres in Aachen Andrew Blake(EMIC) Deputy Managing & Cairo Director (CMIC)

8 MSR Cambridge in Numbers 110 researchers 140 total staff 80 interns per year Plus 10 R&D staff from other Microsoft R&D groups Plus 12 Visiting Researchers per year Over 150 day visitors, seminar speakers per year Staff 1 Turing Award winner 1 Kyoto prize winner 2 Marr prize winners 2 ACM Fellows 1 IEEE Fellow 3 Royal Society Fellows 1 Royal Society of Edinburgh Fellow 4 Royal Academy of Engineering Fellows Honours 70+ top tier publications per year 65+ patents filed per year Outputs

9 Overview Why Microsoft Research? Worldwide Cambridge (MSRC) What are we doing? Research Directions Selected Projects

10 Research Directions Microsoft Research Cambridge Programming Principles and Tools Operating Systems, Networking, Distributed Systems Computer Mediated Living Machine Learning and Perception Computational Science

11 Research Directions Microsoft Research Cambridge Programming Principles and Tools Operating Systems, Networking, Distributed Systems Computer Mediated Living Machine Learning and Perception Computational Science

12 Programming Principles and Tools: F# Functional Objects.NET Tools Strong Typing.NET OO Model Visual Studio F# Compiler Succinct Libraries F# Interactive Type Inference Data Types and Patterns Interoperable Tools Visual Studio Integration 1 st Class Functions Meta-Programming Compact type-inferred classes Concurrency LINQ Extensible Plotting Lex and Yacc

13 OCaml F# C#/.NET Similar core language Similar object model

14 F#: Binding and Type Inference Type inference. The safety of C# with the succinctness of a scripting language Bind a static value Bind a static function Bind a local value let data = (1,2,3) let f (a,b,c) = let sum = a + b + c let g (x) = sum + x*x g(a), g(b), g(c) Bind a local function

15 To the point //F# open System let a = 2 Console.WriteLine a //C# using System; namespace ConsoleApplication1 { class Program { static int a() { return 2; } static void Main(string[] args) { Console.WriteLine(a); } } }

16 More Code! //F# open System let a = 2 Console.WriteLine a a 2 Console.WriteLine a More Noise Than Signal!

17 Pleasure // Use first-order functions as commands type Command = Command of (Rover -> unit) let BreakCommand = Command(fun rover -> rover.accelerate(-1.0)) let TurnLeftCommand = Command(fun rover -> rover.rotate(-5.0<degs>)) Pain abstract class Command { public virtual void Execute(); } abstract class MarsRoverCommand : Command { protected MarsRover Rover { get; private set; } public MarsRoverCommand(MarsRover rover) { this.rover = rover; } } class BreakCommand : MarsRoverCommand { public BreakCommand(MarsRover rover) : base(rover) { } public override void Execute() { Rover.Rotate(-5.0); } } class TurnLeftCommand : MarsRoverCommand { public TurnLeftCommand(MarsRover rover) : base(rover) { } public override void Execute() { Rover.Rotate(-5.0); } }

18 let rotate(x,y,z) = (z,x,y) let reduce f (x,y,z) = f x + f y + f z Tuple<V,T,U> Rotate(Tuple<T,U,V> t) { return new Tuple<V,T,U>(t.Item3,t.Item1,t.Item2); } int Reduce(Func<T,int> f,tuple<t,t,t> t) { return f(t.item1) + f(t.item2) + f (t.item3); }

19

20

21 Single-slide Solution: Unit-checking by Type-checking Declare base units measure kg, m, s and derived units measure N = kg m / s^2 Parameterize numeric types (float, double, etc) on units. Constants are annotated with units e.g. let gravity = 9.81<m/s^2> Compiler checks units Compiler automatically infers generic types for functions Programmer can parameterize own types on units (e.g. complex, matrix, Gaussian) Zero performance penalty all checking at compile-time!

22

23 Research Directions Microsoft Research Cambridge Programming Principles and Tools Operating Systems, Networking, Distributed Systems Computer Mediated Living Machine Learning and Perception Computational Science

24 Systems and Networking: Constellation Problem Complex network applications Dynamic dependencies between services and servers Existing tools are insufficient and require experts Approach Monitor the network to discover dependencies between services and hosts Machine learning to learn local correlations Express global correlations as graphs Applications Troubleshooting Configuration planning Fault detection and prediction Root cause analysis

25 A Constellation from Microsoft s corporate network

26 Research Directions Microsoft Research Cambridge Programming Principles and Tools Operating Systems, Networking, Distributed Systems Computer Mediated Living Machine Learning and Perception Computational Science

27 Computer Mediated Living: SenseCam Idea Automatically capture visual scenes from a person s life Use sensors to determine when interesting pictures can be taken Artificially enhance people s visual memory (Alzheimer disease) Technology 1 GB flash memory for 30,000 VGA images Light-intensity and light-colour sensors Passive infrared (body heat) detector and temperature sensor Multiple-axis accelerometer SenseCam Data Pictures from fish-eye wide-angle lens Time stamps Time series of sensory data

28 SenseCam Footage

29 Research Directions Microsoft Research Cambridge Programming Principles and Tools Operating Systems, Networking, Distributed Systems Computer Mediated Living Machine Learning and Perception Computational Science

30 3D Object Insertion into Video Insert 3D objects into video with a single click Interactively position them using simple 2D tools Depth at each pixel is computed on the GPU Partial occlusion possible

31 3D Object Insertion into Video (ctd.)

32 Research Directions Microsoft Research Cambridge Programming Principles and Tools Operating Systems, Networking, Distributed Systems Computer Mediated Living Machine Learning and Perception Computational Science

33 Stochastic Π-Calculus for Systems Biology Idea Use formalism for concurrency in computer science to describe biological systems Biological systems run their software on a different hardware Technology π-calculus for describing concurrent systems Modify to account for stochasticity Large scale simulations in silico Applications Cell dynamics Immune system Library of genes

34 Computational Science Activities Computational Biology Computational Ecology Environmental Science Natural Computation 2020 Science Report Policy engagements: national academies, funding agencies, government ministers and officials Conference & Project funding INRIA, France - Software Security and Scientific Information Interaction University of Trento, Italy - Systems Biology Barcelona Super Computer Centre, Spain Multi core systems programming Internships PhD scholarships Post Doc Fellowships Summer schools European Science Prize Inspire programme Collaborative Research Programme Scientific Leadership Joint Laboratories Intellectual Capital Development

35 External Research Advanced Research Tools and Services Computer Science Earth, Energy and Environment Education and Scholarly Communication Health and Wellbeing Community, Intellectual Capital Development

36 The Future is Heterogeneous

37 The free lunch is over Transparent CPU perf increase Homogeneous multi-core Heterogeneous multi-core

38 Using multi-cores: space scheduling Partition resources between concurrent apps or VMs Machine consolidation Preserve responsiveness VMs for stronger isolation

39 Using multi-cores: control parallelism Find control-parallelism within an app Multiple threads in a shared address space Handle different clients GC, indexing, etc concurrent with application work

40 Using multi-cores: data parallelism Exploit data parallelism in large computations OpenMP Nested dataparallelism

41 Welcome to deadlock, races, livelock Locks and condition variables (a) are hard to use and (b) do not compose Library Hardware

42 Multi-Core and Parallelism To exploit multi-core processors: Automatically parallelize sequential programs. Modify existing programs to add hints about how to parallelize them. Write new implicitly parallel programs. Write new explicitly parallel programs.

43 Major Multi-Core Issues Difficult to make legacy software exploit multicore processors Some promising work at Princeton (Liberty group) In general it is too hard to implicitly parallelsim

44 Major Multi-Core Issues Difficult to get good granularity of parallelism Many embarrassingly parallel algorithms do not work out because tiny amounts of work cannot be efficiently scheduled across multiple threads or processors.

45 Major Multi-Core Issues Some explicitly parallel programs are nondeterministic Serious verification problem. Requires further advances in static analysis.

46 Major Multi-Core Issues Many existing system level concurrency constructs are not suitable for parallel application development and lack composability: locks monitors condition variables

47 Example: double-ended queue PushLeft / PopLeft work on the left hand end Make it thread-safe by adding a lock Needlessly serializes operations One lock for each end? PushRight / PopRight work on the right hand end Much more complex e.g. lots of lost-wake-up problems Risk of deadlock when queue nearly empty Still not composable Still won t scale up

48 Transactional Memory atomic A.withdraw(3) B.deposit(3) end Steal ideas from the database community atomic does what it says on the tin Directly supports what the programmer is trying to do: an atomic transaction against memory Write the simple sequential code, and wrap atomic around it.

49 How does it work? atomic <body> Optimistic concurrency Execute <body> without taking any locks Each read and write in <body> is logged to a threadlocal transaction log Writes go to the log only, not to memory At the end, the transaction tries to commit to memory Commit may fail; then transaction is re-run

50 Transactional memory No races: no locks, so you can t forget to take one No lock-induced deadlock, because no locks No lost wake-ups, because no wake-up calls to forget [due to retry] Error recovery trivial: an exception inside atomic aborts the transaction Simple code is scalable

51 STM monad; impoverished version of IO atomically is a function, not a syntactic construct atomically :: STM a -> IO a newtvar :: a -> STM (TVar a) readtvar :: TVar a -> STM a writetvar :: TVar a -> a -> STM () incr :: TVar Int -> STM () incr r = do { v <- readtvar r ; writetvar r (v+1) } Transactional variable main = do { r <- atomically (newtvar 0) ; fork (atomically (incr r)) ; atomically (incr r) ;... }

52 STM in Haskell atomically :: STM a -> IO a newtvar :: a -> STM (TVar a) readtvar :: TVar a -> STM a writetvar :: TVar a -> a -> STM () Can t fiddle with TVars outside atomic block [good] Can t do IO inside atomic block *sad, but also good]

53

54

55

56

57

58

59

60

61

62

63

64 Join Patterns Channel A Channel B Channel C Channel D A(x) join pattern & B(y) -> print x+y handler A(x) & C(y) & D(z) -> print x-y+z A(x) & D(y) -> print x-y x=6, y=2, output = 4

65 using System ; Comega asynchronous methods public class MainProgram { public class ArraySummer { public async sumarray (int[] intarray) { int sum = 0 ; foreach (int value in intarray) sum += value ; Console.WriteLine ("Sum = " + sum) ; } } } static void Main() { Summer = new ArraySummer () ; Summer.sumArray (new int[] {1, 0, 6, 6, 1, 9, 6, 6}) ; Summer.sumArray (new int[] {3, 1, 4, 1, 5, 9, 2, 6}) ; Console.WriteLine ("Main method done.") ; } 76

66 Comega chords using System ; public class MainProgram { public class Buffer { public async Put (int value) ; public int Get () & Put(int value) { return value ; } } } static void Main() { buf = new Buffer () ; buf.put (42) ; buf.put (66) ; Console.WriteLine (buf.get() + " " + buf.get()) ; } 77

67 Join Patterns C-Omega language Robotics DSK as a C# library Join Java Perhaps a good model for XMOS?

68 Data parallelism Nested Data Parallelism Do the same thing, in parallel, to every element of a large collection of values Advantages Everything remains purely functional Granularity: one thread per processor Locality: data physically partitioned across processors

69 Flat data parallel e.g. Fortran(s), *C The brand leader: widely used, well MPI, understood, map/reduce well supported foreach i in 1..N {...do something to A[i]... } BUT: something is sequential Single point of concurrency Easy to implement: use chunking Good cost model P1 P2 P3 1,000,000 s of (small) work items

70 Nested data parallel Main idea: allow something to be parallel foreach i in 1..N {...do something to A[i]... } Now the parallelism structure is recursive, and un-balanced Still good cost model Hard to implement! Still 1,000,000 s of (small) work items

71 Barnes-Hut Depth of data parallel nesting determined dynamically. More complex data structure: elements of a parallel array come from a recursive and user-defined algebraic type Barnes-Hut n-body problem

72 p3 p1 p2 p7 p6 p4 Barnes Hut p8 p9 p5

73 p 3 p1 p2 p7 p6 p4 p8 p9 p5

74

75

76

77 XD2000i FPGA in-socket accelerator for Intel FSB XD2000F FPGA in-socket XD1000 FPGA co-proces accelerator for AMD socket F module for socket 940

78

79

80

81 public static int[] SequentialFIRFunction(int[] weights, int[] input) { int[] window = new int[size]; int[] result = new int[input.length]; // Clear to window of x values to all zero. for (int w = 0; w < size; w++) window[w] = 0; // For each sample... for (int i = 0; i < input.length; i++) { // Shift in the new x value for (int j = size - 1; j > 0; j--) window[j] = window[j - 1]; window[0] = input[i]; // Compute the result value int sum = 0; for (int z = 0; z < size; z++) sum += weights[z] * window[z]; result[i] = sum; } return result; }

82 Transposed Filter

83 static void Tap(int i, byte w, Kiwi.Channel<byte> xin, Kiwi.Channel<int> yin, Kiwi.Channel<int> yout) { byte x; int y; while(true) { y = yin.read(); x = xin.read(); yout.write(x * w + y); } }

84 Inter-thread Communication and Synchronization // Create the channels to link together the taps for (int c = 0; c < size; c++) { Xchannels[c] = new Kiwi.Channel<byte>(); Ychannels[c] = new Kiwi.Channel<int>(); Ychannels[c].Write(0); // Pre-populate y-channel registers with zeros }

85 // Connect up the taps for a transposed filter for (int i = 0; i < size; i++) { int j = i; // Quiz: why do we need the local j? Thread tapthread = new Thread(delegate() { Tap(j, weights[j], Xchannels[j], Ychannels[j], Ychannels[j+1]); }); tapthread.start(); }

86 Resources Toward 2020 Science Report Being Human: Human Computer Interaction in the Year 2020 Report Research publications Research prototype software