An operating system for multicore and clouds: mechanism and implementation
0 likes766 views
The document presents Factored Operating Systems (FOS), a new operating system designed for multicore and cloud systems. FOS addresses the scalability and fault tolerance challenges of these environments by factoring the OS into distributed, message-passing services like file system, scheduling, and memory management. It provides a single system image across cores and machines using naming and messaging. Evaluation shows FOS improves performance and scalability over traditional OSes for applications and filesystem operations in multicore and cloud deployments.
Ad
More Related Content
What's hot (20)
Viewers also liked (9)
Ad
Similar to An operating system for multicore and clouds: mechanism and implementation (20)
Ad
Recently uploaded (20)
An operating system for multicore and clouds: mechanism and implementation
- 1. An Operating System for Multicore and Clouds : Mechanisms and Implementation Authors : David Wentzlaff, Charles Gruenwald, Nathan Beckmann, Kevin Modzelewski, Adam Belay, Lamia Youseff, Jason Miller & Anant Agarwal Computer Science and Artificial Intelligence Laboratory, MIT Presenting By : Mohanadarshan (148241N) & Ireshika (138214C)
- 2. Content ● Motivation ● Problem ● Challenges in Muticore and Cloud systems. ● Solution ● Factored Operating Systems ● How FOS solves the problem ● Case Studies ● Results ● Conclusion
- 3. Motivation Source : IEEE Spectrum's special report 2010 & Gartner report 2013
- 4. Problem Multicore and Cloud systems cannot use existing operating systems. ● They cannot scale much. ● It put more responsibility on user to manage the system configurations and resources. ● They does not take full advantage of the increased computational capacity. ● Existing OS are designed targeting on machines which has smaller number of cores. ● Inefficiency in managing faults in large scale systems (with many cores)
- 5. Challenges in Multicore & Cloud Systems ● Scalability ● Variability of Demand ● Faults ● Programming Challenges
- 6. Scalability ● Existing OSs are designed for single processor or to some limited processors. ● There are many scalability limitation exists ➔ Limitations in locking ➔ Locality aliasing ➔ Reliance on shared memory. ● Cloud resources are virtually unlimited for a given user.
- 7. Variability of Demand ● Os needs to manage the live cores to match the demand. but existing OSs only manage the single core (active or idle). ● Cloud computing makes more resources available on-demand (since user expectation can change in run time) ● Demand is not static, it is dynamic.
- 8. Faults ● Hardware faults are more common in multicore or cloud computing system, need to manage them ● System software (OS) must gracefully support dying cores and bit flips. ● Lack of tools to debug and detect faults in multicore or cloud systems.
- 9. Programming Challenges ● Uniprocessor OSs are works in multiprocessor system by adding locks to OS data structure. ➔ Choosing correct lock granularity ➔ deadlock prevention ● Efficient large-scale lock based OS is error prone. ● Application needs to handle most of the scheduling works and needs to manage the corresponding resources.
- 10. Solution Need an Operating system which can be scalable and gives solution for the challenges in Multicore and Cloud operating system FOS
- 11. Factored Operating System (FOS) ● It is a single system image operating system across both multicore and cloud system (IaaS). ● Scalability and adaptability are the main design constraints. FOS tackles OS scalability challenges by factoring the OS into component system services. Here system services further divided in to internet inspired services which communicate through message passing. - File System service - Scheduling - Memory management - Access to hardware & - Fault tolerance - Demand elasticity
- 12. Benefits of Single System Image ● Ease of administration ● Transparent sharing ● Informed optimization ● Consistency ● Fault tolerance
- 13. FOS Architecture
- 14. FOS Architecture (contd..) ● Libfos - Library FOS (Application communicate with servers through this). ● Hypervisor - A hypervisor or virtual machine monitor is a piece of computer software, firmware or hardware that creates and runs virtual machines ● Microkernel - A small microkernel runs on every core proving messaging between applications and servers. ● Proxy network server - It manages the global name mapping ● Namecache - Cached, a small portion of the global namespace.
- 15. Why FOS?... How it solves?... ● OS is factored into function-specific services -Each service is parallel and distributed. Communicate via messaging (Applications can used shared memory if supported). ● Space multiplexing - Belief that there will soon be a time where the number of cores in the system exceeds the number of active processes. ● OS adapts resource utilization to changing system needs - OS closely manages how resources are used. Highly loaded services provisioned more resources. ● Faults detected and handled by OS - OS services are monitored by watchdog process. If a service fails a new instance spawned to meet the demand.
- 16. Messaging ● Simply, focus on the application and communication patterns on a flat communication medium. ● Operating system services are strictly implemented using messages for communication. ● Messaging done via shared memory or network ● Intra machine communication used shared memory ● Sharing of data becomes much more explicit in the programming model. ● There are mailboxes for each processes, to store the delivered messages by other process.
- 17. Naming ● Processes register a particular name for a mailbox ● When an application messages a particular service, the nameserver will provide a member of the fleet that is best suited for handling the request. ● Currently, nameserver implementation uses the preliminary implementation (RR or closest server) but planning to incorporate with ideas like hash tables. ● Complexity dealing with separate forms of interprocess communication in traditional cloud systems is abstracted beyond the naming and messaging api.
- 18. OS Services ● Parallelizes each system service into a fleet of spatially distributed, cooperating servers that easy to scale and dynamically adaptable to changing demand. ● There are multiple fleets active in a system. (eg: file system fleet, name fleet & etc…) ● To accommodate increased demand new fleet members are added dynamically and vice versa. ● OS services are developed based on a cooperative multi-threaded programming model; easy to use remote procedure call; serialization facilities and data structures for common patterns of data sharing.
- 19. Case Study - File System
- 20. Case Study – Spawning Server Create new server process on – decided by spawn server
- 21. Case Study – Elastic Fleet • A watchdog process monitoring the queue length • Add server to fleet ➔ Spawn, handshaking, • Make global decisions of elastic fleet
- 22. Implementation • Xen para-virtualized machine (PVM) OS • Run on EC2 or Eucalyptus cloud infrastructure • Configuration ➔ 16 machine cluster, each has 8 cores running at 3.16 GHz, 8G main memory, 1G Ethernet
- 23. Result - syscall
- 24. Result – fos network stack & app
- 25. Result - FS
- 26. Conclusion ● FOS provides scalability, fault tolerance & demand elasticity. ● FOS is scalable and adaptive, it allows application developer to focus on application level problem solving without distractions from underlying system infrastructure. ● FOS is an highly complex approach which move the complexity from application level to OS level.
- 27. Interesting References ● http://software.intel.com/en-us/articles/performance-scaling-in-the-multi- core-era ● http://spectrum.ieee.org/semiconductors/processors/multicore-cpus- processor-proliferation ● http://www.rackspace.com/knowledge_center/whitepaper/understanding- the-cloud-computing-stack-saas-paas-iaas ● http://machinedesign.com/news/processor-future-multicore ● http://groups.csail.mit.edu/carbon/docs/Wentzlaff.2009.OSR.fos.pdf
- 28. Thank You...