CS 736 Reviews - Spring 2015

I turned in the Xen paper review here as I realized we don't need to write one just after I finished it. I didn't turn in the multi kernel review so this one may take its place.

1. Summary
This paper implements a new design of paravirtualization of Xen, a virtual machine monitor that preserves performance and functionality, as well as isolation and support and commodity OS support. It targets to design a server that can host 100 virtual machines simultaneously by multiplexing.
2. Problem
Supporting multiple guest operating systems on a machine must deal with three challenges. Isolation must be achieved among virtual machines; heterogeneous virtual machines should be supported; and overhead should be minimized. Existing designs such as full virtualization either trade security for performance, or implementation complexity for functionality. New design model is to be developed.
3. Contributions
This paper proposes a new paravirtualization design, which provides a similar but not identical abstraction of underlying hardware.
The virtualization of memory is to let each guest OS manage its TLB and leaving top 64MB in the address space for Xen, because x86 does not support software managed-TLB and we’d like to ensure isolation and save hypervisor intervention time.
Xen executes in ring 0, while guest OSes run in ring 1. Privileged instructions including page fault produced by guest OSes are paravirtualized to be validated and executed in Xen, except for syscall, which is registered with fast handler by guest OS and directly accessed by processor without reference via Xen. Control transfer is done synchronously on the guest OS side by event mechanism while asynchronously on the Xen side via notification. CPU is scheduled by BVT algorithm.
I/O is done by a producer-consumer ring buffer using shared-memory in an asynchronous way. The ring buffer stores descriptors pointing to real data blocks.
Guest OSes have access to virtual time as well as real time to do time sensitive transactions such as networking. Guest OS page tables are directly registered with MMU and read-only. Updating needs a hypercall and Xen validation. Each domain has one or more VIFs like network interface card, in the abstraction of VFR provided by Xen.
Xen does require to modify guest OSes, including privileged instructions rewriting. 1.36% of Linux and 0.04% of WinXP code are modified.
A separation of mechanism and policy extracts configurable system policies to form a control panel called Domain0, which runs above hypervisor.
4. Evaluation
The evaluation is done among native Linux, XenoLinux, VMware, and User-Mode Linux. The relative performance shows that XenoLinux performs closely to native linux and far better than VMware and UML. However, the criteria are not consistent (sometimes it’s time; sometimes it’s throughput; configurations vary a lot.) and thus comparability and objective of comparison is questioned. The overhead of XenoLinux doing syscalls is better than VMware and UML. Networking shows visible performance degradation only when MTU is significantly reduced. Concurrency on web service shows good latency as well as throughput on two domains than more domains, so does isolation performance. This is due to frequent context switch that slows Xen down. Finally, Xen shows great scalability that can hold up 128 clients with almost no throughput reduction when time slice is large; small time slice causes context switch overhead which undermines the performance by 7.5%.
5. Confusion
I am still confused about two mechanisms in the paper: 1) what is the different between expections handled in Xen and in regular Linux system? They all seem to “trap” into kernel-privileged mode. 2) How is page table registered to MMU and how can Xen validate on registration and/or update?

1. summary
This paper presents Multikernel along with its prototype Barrelfish, a new architecture for OS designed to achieve better scalability across diverse multicore hardware systems. Apart from the design principles this paper also presents implementation details of Barrelfish and its evaluation on various workloads. Finally they claim that this distributed systems inspired approach is at par in performance with the monolithic OS but has a better scalability on heterogeneous hardware and is future proof.
2. Problem
There was a fast paced growth in the hardware design but, systems software was unable to cope up with that pace. To accommodate with the diversity in hardware, many hardware related optimization were done in OS. These optimizations were forced to change as new hardwares came in. To decouple this dependency and to make OS future proof this paper presents a distributed systems like approach for OS.
3. Contributions
The Multikernel model is guided by three design principles:
1. Make all inter-core communication explicit.
Instead of sharing memory between cores for communication all communications are done using message passing. This provides modularity as communications are done suing well defined interfaces.
2. Make OS structure hardware-neutral.
As discussed above, this makes OS scalable and future proof. The message passing mechanism and hardware interfaces are hardware dependent.
3. View state as replicated instead of share
Instead of sharing memory, each core have their own replica of state. Consistency between these states are maintained. This replica is available closer to the core thus has better performance.
4. Evaluation
A good evaluation of the protoype Barrelfish against the conventional OS is presented. In a common intercore communication like TLB invalidations Barrelfish performs slower than shared memory for small core counts but scale very well and has better performance when the core count increases. Evaluations for computer bound and IO bound operations are also presented. From the presented evaluations it can be seen that Barrelfish performs at par with the conventional OS while scaling better than them.
5. Confusion
How the consistency between the replicated state is maintained ?

1. Summary
A new OS architecture - Multikernel, inheriting major features and insights from distributed systems is investigated in this paper. Multikernel model is restructured mainly to exploit contemporary diverse hardware architectures and to address scalability issue of processor cores. It takes advantage of the distributed nature of hardware nodes communicating through explicit message passing. Barrel fish, a prototype of Multikernel is implemented and tested on variety of hardware platforms, with message passing scaling well with large number of cores whereas compute workloads performing almost same as traditional OSes.

2. Problem
With the ever changing technology to push Moore’s law to limit, the processor architecture is becoming more and more diverse switching to heterogeneity and moving towards scalable architectures to adapt to high performing applications. Traditional monolithic OSes have a huge challenge to address this scalability issue and to optimize for diverse hardware structures. Authors in this paper have tried addressing this problem by using explicit message passing between cores and replicating kernel state across cores, rather than shared memory model. Their another main goal is make this OS hardware neutral thus, not targeted for any machine architecture.

3. Contributions
Multikernel OS main contribution are embedded in their three design principles - making Intercore communication explicit via message passing, making the OS hardware neutral and to replicate kernel state across cores. The system focuses on a non-shared memory model, maintaining the cache consistency and coherency by explicit communication through messages. Their experiments show that with scaling thread/core counts, message passing proves to be performing better than shared memory model. System structure has low-level CPU drivers providing access to hardware structures and the User monitors responsible for monitoring RPCs between the cores. The kernel state being replicated across the cores would make the possibility of having diverse cores in the system and and thus not optimize OS for individual architectures.

4. Evaluation
Barrelfish prototype has been tested on many multiprocessor systems like Intel Xeon and AMD Opteron chips. Although, there is no strong mention of methodology they have used, there are lot of performance results mentioned in the paper. User level RPC call performance numbers on same processor cores and different cores show that message passing latency and throughput is still in acceptable limits . TLB shutdown and memory unmapping performance have been compared for different message passing policies and OSes, for varying number of cores. The results show that Barrelfish although performing bad for lower core counts, scales well with the increasing core count. Performance of Barrelfish for compute workloads on an AMD machine proves to be similar to Linux OS. Empirical data along with their reasoning of why multi kernel performs bad or good in certain situations is explained well.

5. Confusion
How are the CPU drivers aware of the workload behavior being run in the system? Who is responsible for data partitioning among the cores which is an expensive operation by itself? A discussion of interfaces and abstractions (dispatcher objects etc) of drivers and monitors would be helpful. How does Multikernel performance compare to shared memory models with modern faster interconnect networks (photonic ones)?

Summary:

In this paper, the authors make a case for the multikernel, an operating system which is designed to treat the system as a network of interconnected cores that communicate through message passing. The authors also describe Barrelfish, their implementation of a multikernel.

Problem:

The authors identify issues with current operating systems and hardware which is increasingly heterogenous and multicore. Due to the way current operating systems are optimised for particular hardware, they become difficult to port. In addition, the performance of shared-memory kernels isn't scalable with increasing the number of cores in the underlying hardware. The authors also feel that hardware which is traditionally considered to be devices should also be managed by the OS.

Contributions:

The biggest contribution of this paper is presenting a working, distributed system built over existing hardware. The authors used quite a bit if ingenuity to implement inter-core message passing through the cache coherence system and the underlying network.

The authors raise a number of issues that current operating systems could face with the way that hardware is evolving. I think that dealing with heterogenous systems is a valid concern and a distributed kernel structure does look like an interesting, potential solution. However, the authors don't really address how applications could be compiled for these distributed kernel systems.

Their support of the claim that message passing could one day replace cache coherence is a little more unclear. Systems could evolve to use message passing for inter processor communication but still rely on cache coherence for intra processor synchronization.

Evaluation:

The authors compare a few explicit communication strategies using TLB shoot down, a process which requires global synchronization. They do so to show that the hardware discoverability feature if Barrekfish could be used optimized software and their results back them up.

The authors compare Barrelfish performance with Linux through the SPLASH-2 benchmark suite. They picked this benchmark suite to show that Barrelfish can support shared-address-space parallel code. They also compare performance with a web server. In most of these cases, Barrelfish is competitive with Linux or outperforms it. This is impressive considering that Barrelfish was hacked together to work with shared memory multicore processors.

One issue with the way that Barrelfish was tested is that it's difficult to determine if performance improvements are due to having things done in the user-space or the distributed structure of the multikernel.

Confusion:

I don't understand how the system knowledge database is different from the way that hardware optimizations are currently done. I understand that it could be useful in a heterogenous system but I don't see how software constructed to use this information is any more portable than the current hardware optimized systems.

Summary:
The paper presents the multikernel approach towards the design of the operating system which treats the OS as a distributed system on different cores, i.e. each core potentially running an instance of the operating system. This is a replicated state operating system, which does not use shared memory but uses message passing instead to maintain the same state across cores. One such implementation of the multikernel: Barrelfish is described in the paper.

Problem:
The hardware is changing faster than system programs could adapt to it. How can operating systems be made hardware neutral? Because of the dynamic nature of workloads, Operating Systems need to be highly optimized to achieve a good throughput. Is there a way to reduce the time required to tune the system? Also, as the core count increases shared memory latency is increasing. How can we rethink the OS architecture by using ideas from distributed systems and build a scalable operating system. This is the primary problem addressed in the paper.

Contribution:

1. Design of the OS as distributed system of cores and use message passing without shared memory: To improve throughput, use message passing since share memory is getting expensive as core count is increasing.
2. State replication: Using message passing the OS state across multiple cores is synchronized. Since intercore communication mechanisms are getting better, this aims to achieve improved throughput.
3. Hardware neutral OS structure: The multikernel barrelfish implementation is catered to be hardware neutral since the OS is isolated from the hardware thus making the system easily configurable on heterogeneous architectures.
4. Use a microkernel approach on each core, thus reducing the OS features to a bare minimum.

The use of message passing was not a new approach, but achieving a challenging task of heterogeneity across hardware would be the prime contribution of this paper.

Also, a key idea here as stressed by the authors is that Barrelfish is just one type of highly optimized implementation of the multikernel.

Evaluation:
Evaluation results shows barrelfish compares almost equivalently on standalone systems compared to the existing Operating System Design. The authors compare latency for invalidating TLB entries using different approaches like broadcast, unicast and multicast. A set of benchmarks from the NAS OpenMP suite is used for compute workloads to show that Barrelfish performs equivalent to the current OS design. The authors accept that one of the reasons for this performance is also the concern that barrelfish is highly optimized and lightweight with bare minimum features. But it would be 'reasonable' to assume that this design could lead towards a scalable OS.

Confusions:
1. Is there a load balancing feature to achieve maximum throughput across nodes in a distributed environment?
2. Each instance on a core seems like a microkernel. What would be the implication if a different design implementation of the multikernel uses a monolithic kernel?

Summary
The paper mainly discusses about the structure and design principles of a new operating system called 'multikernel' whose performance is independent of the hardware model(i.e number of cores or core architecture) underneath it and views the machine as a network of cores and distributed processes that communicate via message-passing rather than shared memory.
Problems
The current OS designs are optimized for a common hardware case and hence are less efficient as the hardware underneath it becomes diverse. These optimizations becomes obsolete when a new hardware arrives. There are scalability issues for cache coherent shared memory even with a small number of cores. Although the current OSes have solutions to theses problems, they are specific to a particular hardware, and hence there is a need for a system which is hardware neutral and support efficient process communication.
Contributions
The paper puts forward the design and implementation principles of a mulitkernel operating system Barrelfish, that satisfies the goals of scalability and adaptability to hardware characteristics while providing competitive performance on contemporary hardware.All inter-core communication is performed using explicit messages. Using messages to update a state is more efficient than shared-memory access when the number of process involved increases. The system is independent of the hardware structure, hence easy to run on varying hardware architectures. The OS state is replicated across the cores and hence any access/update are made as if its a local replica. By bringing the data nearer to the cores will result in lowered access latencies and thereby better performance. The OS instance on each core is factored into a privileged-mode CPU driver that enforces protection,authorization, time-slice for process and a user-mode monitor process that coordinate the system-wide state.
Evaluation
The paper evaluates the performance of the multikernel based on the specific workloads designed to exercise various parts of the OS. TLB shoot-down latency is measured and compared with contemporary OS for various URPC-based protocols. Though the message passing design is slower than shared memory, it is faster for higher core counts. The performance of workloads and IO workloads is identical to those of conventional systems which is mostly due to user-space threads library.
Confusion
Didn't understand the split phase communication mechanism.

1. Summary
This 2009 paper outlines the design concepts and implementation of a multikernel architecture. Issues with current OSs are presented, then the multikernel approach is described and evaluated using the Barrelfish implementation.

2. Problem
Computer hardware today is changing and diversifying quickly. Multicore processors are common in every type of hardware, ranging from supercomputers all the way to mobile devices. There are already a number of mature operating systems for high-performance supercomputing, but these are not suitable for a general purpose OS. Complex current operating systems simply cannot optimize for efficient use of new hardware as quickly as the hardware evolves. Finally, as the number of cores in devices increases, protocols like cache coherence struggle scaling.

3. Contributions
The main contribution of the paper is the idea that the future OS should be structured primarily as a distributed system. This leads to several specific design principles: explicit interprocess communication, hardware-neutral structure, and the viewing of state as replicated across cores rather than shared.
Explicit interprocess communication means that no memory is implicitly shared via the OS. This allows for a number of networking techniques and asynchronous (split-phase) operations that can improve efficiency. It also means that the issue of heterogeneous cores is mitigated, as hardware specific implementations can be easily handled via CPU drivers. This leads to the concept of hardware-neutral structure: the OS has been separated into a CPU-specific driver and a general monitor. The driver essentially acts as a hardware specific exokernel, while the monitor performs the typical mechanism/policy in a typical OS. The user-space monitor handles the maintenance of global state between cores and provides the basis for messaging between processes.
Another interesting contribution of the paper was the Multicast knowledge/policy engine. In this case, a central knowledge kept track of hardware architectures, and allowed the system to modify itself at runtime for efficiency (for example, creating a hierarchical topology of messages in each process for multicast).

4. Evaluation
The Barrelfish OS was implemented in order to attempt to benchmark performance with respect to traditional operating systems. The goals of this implementation are explicitly mentioned, and include comparable performance to existing OSs, and evidence of scalability to large numbers of cores. The authors present a number of graphs to present what they view as a success. In the TLB-shootdown example, there is evidence that building a hardware aware, multicast system performs scales much better than typical cache coherence algorithms and the number of cores increase. There are also IO/compute bound workloads that show comparable, or slightly improved performance for Barrelfish over Linux. The authors conclude by saying because Barrelfish is simple and unoptimized, the performance will improve (and will scale more effectively as the number of cores increase).

5. Confusion
What is the relation between monitors/dispatchers with respect to message passing? (The paper mentions that communication occurs between dispatchers - do these dispatchers directly send messages to each other, or do they go through the monitors on each core.)
Our discussion group talked about the issue of global optimization (ensuring efficient use of cores by scheduling jobs on each). Would this be handled as a distributed algorithm in this case?

1. summary
The paper introduces the multikernel OS structure, which assumes no inter-core sharing and communicates via message-passing. The author implemented Barrelfish system based on the structure.

2. Problem
The computer hardware is changing and diversifying fast. Most computer have multicore processors and future core counts will increase. It's not possible to tune a general-purpose hardware design for a particular hardware model and the optimizations are not portable between different hardware types. The problem can be contributed to the share-memory OS design and thinking OS as a hardware-neutral distributed system of functional units communicating via explicit messages can solve this problem.

3. Contributions
(1) Propose three design principles including make all inter-core communication explicit, make OS structure hardware-neutral and view state as replicated instead of shared. Message-passing communication applies well-known networking optimizations such as batching, enables the OS to provide isolation and resource management on heterogeneous cores, makes operations split-phase and is good to human/automated analysis. Making OS structure hardware-neutral makes the structure adaptable to new hardware, isolates distributed communication algorithms from hardware details, enables late binding of both the protocol implementation and message transport. Replicated states increase the scalability, supports changes to the set of running cores.
(2) Implement the Barrelfish system based on the multi-kernel structure. Each OS instance is factored into a privileged-mode CPU driver and a distinguished user mode monitor process (coordination). A process is represented by a collection of dispatcher objects. Communication is via messages. The message management is based on a capability system. Multiple dispatchers and share a single virtual address space. SKB maintains knowledge of hardware.

4. Evaluation
The author compared the Barrelfish system to Linux and Windows on baseline performance, scalability with cores. The experiment covers TLB shutdown and multiple workloads including compute-bounded workloads and IO workloads. It shows that the communication protocol has good performance and can be accelerated by hardware knowledge. Besides, the protocol shows good scalability, outperforming Linux and Windows.

5. Confusion
In the message-passing model, the message-passing will take time. What if the first core has sent out message, but the second core hasn't received it and does a task which will access the data that should be modified by the message? Is there any logical order constraint?

1. Summary
    This paper introduces a new Operating Systems structure, the "multikernel" that treats the machine as a network of independent cores, assumes no inter-core sharing at the lowest level, rethinking the structure of the OS as a distributed system of processes communicating via explicit messages. This allows the OS to adapt, scale and exploit the ever diversifying and improving hardware compared to conventional systems. Barrelfish, an implementation of the multikernel is presented, evaluated for adaptability and scalability and shown that it can provide competitive performance on contemporary hardware.

2. Problem
    Two trends are evident with respect to machine hardware: it is changing faster than software and it is diversifying, both between cores in a machine, and between systems with varying properties and use-cases. Current OS designs optimize for the common hardware case which becomes less ans less efficient as hardware becomes more diverse and cannot exploit the ever improving hardware.
    Cache-coherent shared-memory operating systems are suited for a limited number of homogeneous processors and have scalability issues with future hardware directions. Future general purpose systems will have limited support for hardware cache-coherence, or drop it entirely in favor of a message-passing model
    The authors set out to rethink the OS with the above points in perspective. They wanted a system that will adapt and perform well in the ever-changing landscape of hardware innovations.

3. Contributions
The main contributions of this work are as follows:
    Introduction of the multikernel model and the design principles of explicit communication, hardware neutral structure and state replication.
    Since multicore machines resemble complex networked systems, viewing the OS as a distributed system was a new way of looking at the OS. This allowed for local optimizations rather than designing for a generalized hardware in case of a centralized operating system. Applying techniques from distributes systems and networking like replicated data, message passing between cores and split-phase operations could overcome the drawbacks of conventional systems that did not work well with the diversifying hardware.
    Multikernel relies on message-passing as an explicit communication mechanism between cores to be more efficient than implicit shared memory communication. Message-passing event-driven asynchronous programming model is also the norm for many other programming domains such as GUI programming, some types of network server and large scale computation on clusters.

4. Evaluation
Barrelfish was evaluated for how well it meets the goals of the multikernel OS.
    The paper presents a case study of TLB shootdown, which is a very good candidate to measure the global coordination in a multiprocessor OS. The message-based base protocol used to unmap operations in Barrelfish outperforms the equivalent IPI-based mechanisms in Linux 2.6.26 and Windows Server 2008 R2 Beta, Enterprise Edition. However, the complete implementation of unmapping pages in Barrelfish has not been optimized and adds large overheads thus making it much slower in practice.
    Another use-case of two-phase commit operation for changing memory ownership shows that message-based Barrelfish consumes fewer cycles than IPI-based TLB-shootdowns on Windows and Linux
    IP loopback can be a useful stress-test of the messaging buffering and networked services of the OS. The paper presents a table to show that Barrelfish achieves higher throughput, fewer cache misses and lower interconnect utilization compared to Linux by using UPRC.
    Benchmark tools like OpenMP and SPLASH-2 are used to measure the performance of parallelized applications on Barrelfish and they seem to perform well in spite of its distributed design.
    UDP throughput of Barrelfish matches that of Linux and web-server on Barrelfish outperforms its performance on Linux
    The authors conclude that a lot of effort has been put to optimize the current OSes like Windows and Linux for the existing hardware in contrast to their system which is new. Hence, the above evaluation results are encouraging but far from proving that they will perform well for all kinds of workloads.

5. Confusion
    This is more of a question than confusion. Will the performance of distributed systems like Hadoop, etc. be better on such systems than running them on Linux?

The Multikernel: A new OS architecture for scalable multicore systems
Introduction:

In this paper, the authors describe the idea of the new OS structure, the multikernel which moves away from the traditional idea and considers the machine as a “network of independent cores”. They talk about BarrelFish which is an implementation of the multikernel idea and evaluate its scalability and adaptability.

Conventional operating system are not well suited to exploit the features of the diverse hardware because of its heterogeneous and dynamic nature. The multikernel approach tries to decouple the hardware dependency of an operating system from the mechanisms it provides. If all the cores in the machine are treated as a network of cores, there rises a problem of synchronization between these cores. Predominantly, this paper tries solve the scalability issue of the current operating systems. Also using a distributed system approach there is a need to move from the shared memory system to message passing system.

The key idea was to take a distributed system approach towards the machine such that there was an independent OS for each core. All the intercore communication becomes explicit due to the use of messages and is faster than shared problem as the there is no cache coherence. The multikernel approach makes the OS hardware neutral such that only the interface to the hardware and message transport mechanisms are hardware dependent. Multikernel follows the idea where a global OS state is replicated across cores. By sharing a replica of the system state between groups of closely coupled cores protected by shared memory synchronization an optimization of replication is achieved. CPU drivers act as an abstraction over the underlying hardware and provides hardware neutrality. Monitors encapsulate the system wide state and encapsulate the mechanism and policies found in a kernel of traditional OS. A collection of dispatched objects represent a process such that there is one object on each core on which it might execute. Inter core communication is done using a variant of user level RPC. URPC messages are received using polling mechanism as it is cheap because the line is in the cache until invalidated.

The Barrelfish multikernel is tested to evaluate the baseline performance, scalability with cores, adaptability to different hardware, modularity and message passing. We find that Barrelfish outperforms Linux and Windows Sever when the end to end unmap latency is measured. Also on aspects of messaging performance, message passing is slower than shared memory for lower core counts and faster with higher core counts. Though the Barrelfish system was tested against the popular hardware present, there is no evaluation on its scalability over newer hardware or the ability to integrate heterogeneous cores. I felt that the Barrelfish multikernel performed well for a system in a nascent stage.

What is an exokernel? The authors say that monitors keep the data structures on each core consistent by means of an agreement protocol. How does this work?

1. Summary
A new OS structure is investigated called the multikernel which treats a multicore machine as a network of independent cores. No intercore sharing is allowed and all communication between cores is through message-passing. This model is then applied to BArrelfish and positive results were evaluated.

2. Problem
When systems are becoming increasingly diverse, optimizing for any particular hardware is useles because of very fast pace of evolution of hardware. A lot of refactoring of code becomes necessary later in such cases. The cores in a system are are becoming heteregeneous slowly. Now the only way the CPU cores talk to the GPU cores is through drivers. More utility could be drawn out of those GPU cores had we been able to run a distributed OS like Barrelfish on all CPU + GPU cores that talk through message passing.

Interconnect costs are also increasing rapidly and basing on them shared memory communication grows rapidly as the number of threads sharing a cache line increase.For a shared memory model, we need cache coherence which is not here to stay for very long. When the number of cores increase even a single cache miss at a core can stall the core more many hundred cycles for the cache coherence protocol to operate. Cache coherence may get the job done but decreasingly so as the cores increase in number. Also writing programs using message passing is becoming easier. It's an event driven programming model used by many current programming domains like graphical user interface programming.

Large scale high performance cluster programming is essentially 100% based on message passing. So we have enough problems/motivation at hand to go for a multikernel model.

3. Contributions
The contribution is to make all inter-core communication explicit. This allows the OS provide isolation and resource management on heterogeneous cores. Allocations can now span cores even if there are not cache coherent only if they pass messages. Message-passing also contributes to the realization of split-phase communication in which the sender does not have to wait for the receiver respond before continuing. Also a system based on explicit communication is amenable to automated or human audit.

Another contribution is to make the OS structure hardware-neutral. Adapting the OS to run on hardware with new and enhanced features will not demand massive code restructure in the OS. Hardware-independence means that hardware specific details which are crucial to performance of inter-process communication is separated from the distributed communication algorithms.

Another contribution is to view state as replicated. In the multikernel, unlike conventional OSs like Linux and Windows in which OS structures are bound by local locks and only a very few strictures are replicated across all cores for expediency, in the multikernel the global OS state is replicated across all cores. This can improve system reliability by reducing load on the system interconnect because OS structures can be located in local cache lines. Replication also helps to manage things like hot-plugging or fail-safe removal of cores because an outgoing failed core carries no extra state along with it as any other core.

4. Evaluation
The authors compare TLB consistency when entries are invalidated by increasing the number pf threads. The latencies scale well for non NUMA machines while for NUMA machines the latencies remained almost constant for the process. However in complete end-to-end page unmap procedure, Barrelfish quickly outperforms the equivalent IPI-based mechanism in Linux 2.6.26 and Windows Server 2008 R2 Beta.

In IP loopback tests Barrelfish achieves higher throughput, fewer cache misses and lower interconnect utilization than Linux. This was because Barrelfish had to only send packets as URPC messages thus avoiding any shared-memory other than the URPC channel and the payload. Also, there were no kernel crossings involved in Barrelfish.

In compute benchmarks like OpenMP and SPLASH-2, Barrelfish performed equally well as Linux in most of the benchmarks barring a few like the OpenMP integer sort

5. Confusion / Discussion
To be able to be called a real distributed OS that can run on commodity hardware, apart from running on NUMA aware multiprocessor boards, Barrelfish should also use interconnects like the ubiquitous Ethernet to aggregate cores across moterboards to build clusters and then measure performance of state migration/replication, thread migration and interconnect stress.

Summary :
The paper talks about a multikernel operating system that has been developed with the idea of a distributed system design whose main objective is to manage better the diversity of underlying computer hardware architecture and also the increasing number of cores. They also prove that message passing performs significantly better as compared to shared memory in such a setup. The evaluation of a prototype named Barrelfish is discussed for a varying set of loads and the results show comparable performance results.

Problem :
With heterogenous hardware architectures and the varying number of cores in a multiprocessor system, it is required to reconstruct the OS such that it is hardware neutral and also ensure that the system is scalable.

Contributions :
1. Decentralized design of the operating system using principles of distributed systems.
2. The evaluation of the cache coherence overhead in a system with a large number of cores and a monolithic OS has showed that it restricts the scalability of the system. Therefore, the design considers to replicate the view state on the various cores and have only fine-grained locking.
3. Replication leads to reduction in the synchronization overhead. The OS provides the advantage of improved performance and availability due to replication but at the cost of maintaining the consistency of the replicas.
4. The consistency of the replicas is maintained using well known agreement protocols.
5. They have implemented a prototype of a multikernel OS and have evaluated its performance against a monolithic OS. Each instance of the OS is separated into a CPU driver and a monitor. The CPU driver takes care of the scheduling and access to the underlying hardware. The monitor is responsible for co-ordinating the global state and runs agreement protocols for the same.
6. Usage of the two phase commit protocol by the monitors to ensure that the changes to memory are ordered amongst the processors in the system.
7. A system knowledge base service that contains the knowledge of the underlying hardware and is collected through hardware discovery helps in choosing the suitable message passing mechanisms.

Evaluation :
The paper has provided us with the evaluation of Barrelfish for both CPU bound and I/O workloads and shows reasonable performance.They have also evaluated the throughput of the system and have compared it to Linux. As most of the main mechanisms are hosted by the monitor which is a user-level process, there is less of kernel interaction and therefore, the number of requests served is high. Another reason that adds on to it is the fact that the state is replicated across the processors.

Confusion : What is the upcall interface for each dispatcher mean? What is the stack ripping concern in message passing?

Summary
This paper introduces an entirely new idea namely “multikernel” for an Operating system. The authors wish to view OS as a distributed system where different functional units can communicate through messages. The main motivation towards building such an OS was to make the OS hardware neutral as well as independent of nature of workload. Prototype of such a multikernel called Barrelfish was built and its performance evaluated.

Problem
Current hardware systems are continuously evolving and it is not feasible to design OS specific to each. Authors claim a multikernel approach in order to make OS flexible and ubiquitous. In a single machine again there could be different types of cores and current OS have to find a way to work with each of these architectures differently. Multikernel aims at removing this dependency such that OS should be able to manage the software running on the cores.

Contributions
Multikernel model of an OS was designed and presented in this paper. This design approach tackles a variety of problems. Explicit inter-core communication provide isolation and resource management. A message passing system modularizes requests and this property can be exploited to deliver any kind of message within system components. Switching to a hardware with newer characteristics also becomes easy since due to the well-defined interfaces. Also since the OS must be accessible to all processors, a global OS state replicated around all cores is maintained. This improves system scalability.

Evaluation
Based on the mutlikernel design, authors implemented an OS called Barrelfish. Performance testing was done on x86-64 multiprocessors. To validate the global functioning, the system was evaluated with other OSes by measuring latency and critical operation taking advantage of the message passing system. The system also has been stress tested and otherwise too for I/O workloads and network throughput. Rigorous testing show a lot of similarity to the conventional OS here and there.

Confusion
How will a Barrelfish like system (multikernel) react when the processor/cores are all very similar that is not heterogeneous?

Summary:
This paper talks about the design of a 'multikernel' system , which is an operating system that is distributed across multiple processors, consiting of multiple modules collaborating through messages .

Motivation:
The authors feel that the trends in computer hardware industry point to a future where an extremely diverse market with multi-core systems will be the norm, and they believe that a hardware neutral, decentralized operating system that defaults to message passing will be a very good fit for such a hardware. Here they attempt to build one such multikernel (barrelfish)

Contributions:
The important ideas in the design of barrelfish are:
- Hardware neutrality: The idea of of isolating hardware dependencies in a part of the OS, so as to make the system more portable.
- The idea of a replicated kernel state machine.
- The growing importance of message passing as an alternative to shared memory and the idea that in a multi-core environment asynchronous message passing might be much more efficient due to lack of cache coherence overheads.
- The idea, similar to microkernels, of minimizing kernel level code and complexity and having user level applications( i.e. monitors) handle most of the policies and even mechanisms such as message passing between cores

Evaluation:
The paper talks about a set of domains/ problems where the authors have evaluated barrelfish against existing commercial operating systems and show that with increasing number of cores the performance of barrelfish scales much better.They also show that since the barrelfish system has minimal user-to-kernel mode switches as most of the code is on user space, its performance improves.

Confusions:
The authors talk about the advantages (scaling etc.) of having a decentralized message passing general purpose operating system,but are there some challenges (other than consistency issues of replicated data) that were unique to distributed systems earlier that general purpose operating systems are facing now because of increasing no. of cores?

1. summary

The paper introduces the concept of a multi-kernel operating system where the system is viewed as a network of indpendent cores which
communicate mainly through message passing. The authors put forward arguments in favor of such a distributed design and discuss implementation details which make such a system possible. Finally, they also evaluate the success of their implementation.

2. Problem

The authors contend that a shared-memory kernel introduces a host of challenges to operating system design.

The main issue is that in a shared-memory model, the OS design has to be fine tuned to the hardware. This is costly and also means that design is not portable between different hardware and may not even be applicable to future generations of the same architecture. The example of recent widespread changes made to windows 7 and linux is used to prove this point.

Furthermore, not only is diversity an issue across the range of machines, it is also a problem within a single machine where the characteristics of different cores may vary. Hence, the OS is required to manage the performance across these various cores.

Finally, messaging is also put forward as a better alternative to shared memory as it is shown to be more time efficient due to the synchronous nature of the transmission. The authors also argue that messaging would better fall in line with established software engineering principles and point out the correctness and performance issues that arise from using shared data structures.

3. Contributions

The main contribution of the paper is to show the feasibility of the multi-kernel model through the implementation of Barrelfish. Through the developent of Barrelfish, the authors have managed to show that it is possible to develop an operatins system which satisfies their 3 primary goals.

1) Make inter-core communication implicit

No memory is to be shared between code running on different cores (other than for messaging channels). All communication is performed using explicit messages.

2) Make the OS structure hardware-independent

Only the message transmission mechansisms and the interface to the hardware is to be targeted at specfic machine architectures. This is enable the system to be re-targeted at different hardware without extensive refactoring

3) Make state replicated

Global OS state is to replicated across cores. This is in contrast to traditional systems where the state exists as shared data structures.

4. Evaluation

The paper evaluates the performance of Barrelfish under different types of workloads and hardware. Compared to Linux and windows, we see that Barrelfish performs poorly on the task of unmapping pages. However, Barrelfish outperforms Linux on IP Loopback. The performance of Barrelfish is comparable to the other two operating systems on compute-bound workloads.

5. Confusion

I am not too familiar about the part about diversity between cores where it seems that the authors imply that different cores specialize
in different types of computation. Are such diverse cores present in machines today and if so how do they aid in performance?

Summary:
The paper talks about Multikernel - an operating system structure built from a network of independent cores aiming to distribute OS functionality. Processes running on multiple cores communicate via message passing. The authors claim that the proposed distributed operating system structure is more scalable. An implementation of the proposed system is described by Barrelfish and results are shown to be comparable with Linux.

Problem:
Developments in the system software are not able to cope up with the fast growth in hardware. Optimizations done w.r.t a particular hardware become obsolete as new hardware model arrives. Hence, there is a need to separate OS structure from hardware.

Contribution:
1. Explicit inter-core communications expicit
- Isolation and resource management, efficient scheduling of jobs taking communication patterns into consideration.
- Ease of network optimizations
- Modularity in message passing system increases as communication is through well defined interfaces.
2. Hardware-neutral OS structure, making it more adaptable to various hardware architectures (extensibility).
3. View state as replicated instead of shared: Replication helps to improve scalability via reducing load on system interconnect, memory contention and overhead for synchronization.

Evaluation:
Multikernel OS prototype - Barrelfish has been tested on various mutli-cores for its hardware independency claim. Performance gains reported are attributed to processing in user space and minmal user-kernel crossings. TLB shootdown test compares the interprocessor interrupts in Linux and Windows server and message passing in Barrelfish. Barrelfish achieves a good shootdown performance by leveraging its knowledge of underlying hardware.

Confusions:
I found Monitors and dispatcher role a bit confusing to understand.

1. Summary
Machines, nowadays, are increasingly moving towards multi-core multi-socket designs with varying interconnect topologies, and conventional general-purpose OSes are not adaptable to this varying diversity in hardware. The authors propose a novel OS architecture, multikernel, which models the machine as a network of independent cores borrowing heavily from the distributed systems literature. They design and implement an OS, Barrelfish, based on this OS architecture.

2. Problem
To rethink OS architecture in the face of increasingly diverse hardware configurations, especially in terms of increasing number of cores and processors and varying interconnect topologies with different cache coherence protocols.

3. Contributions
The authors identify non-adaptability of conventional OSes to diverse new hardware as a key issue, and propose a shared-nothing OS design paradigm, which uses message-passing as a first principle, and views state as replicated instead of shared as in conventional OSes. Another key design principle in this model is to structure the OS in a hardware-neutral manner, and move the hardware-specific implementations into message-passing communication across cores. The authors implement and benchmark Barrelfish designed based on these design principles.

4. Evaluation
The authors compare TLB invalidation latency in Barrelfish, Windows and Linux as they vary the number of cores in the machine, and show that Barrelfish scales well compared to others. They benchmark message-passing by comparing IP loopback performance in Barrelfish and Linux. However, this is partly an unfair comparison, since Barrelfish uses an user-space IP stack that avoids the overhead of making a system call for each message sent/received. They also compare the performance of the compute intensive OpenMP benchmarks in Barrelfish and Linux. Barrelfish is comparable to Linux except one case (integer sort), where Barrelfish is ~25-33% worse than Linux.

5. Confusion / Discussion
Hardware architects work very hard to present a shared-memory view of hardware to OS and applications by designing complex interconnects and cache-coherence protocols. Does this work push for rethinking of hardware designs optimized towards shared-nothing architecture with message passing? How can a conventional sequentially executing process be scheduled/pre-empted on the process model in Barrelfish, which is a set of dispatchers with upcall interfaces?

Summary:

This paper introduces a multikernel OS, that imagines the machine as a network of independent cores. It rethinks the structure of the OS as a distributed system on many cores that communicate between them through message passing. An implementation, called Barrelfish has been presented with the details of process, memory and communication abstractions.

Problem:

With diverse set of hardware architectures available today it becomes difficult to optimize and scale monolithic OS for all of the variants present. The authors try to decouple the OS from the hardware. A more efficient form of inter-core communication through message passing is explored because with high number of cores in today's machines, cache coherence schemes are increasing difficult to implement.

Contributions:

The main contributions are the multikernel paradigm, replication of the kernel state across all cores, inter-core communication through message passing instead of shared memory. When a message-passing system is used the machine can be considered as a network and various optimizations can be applied for faster communication between processes. It makes the OS hardware neutral and the only dependence on hardware are the CPU drivers and the devices. This makes the system scalable and adaptable.

Evaluation:

The authors provide various types of comparisons of the prototype Barrelfish to Linux and Windows. They demonstrate that certain operations can scale well and can be better optimized if a message-passing interface is used, eg. TLB shootdown. On CPU and I/O based workloads the performance of Barellfish is similar to that of Linux.

Confusion:

The implementation of the System Knowledge base. Also, a discussion of the state-replication in class will help.

Summary: This paper introduces a new OS architecture called multikernel. In multikernel, each core of the processor is managed by a separate OS kernel, and kernels do not share memory with each other. Instead, they communicate with messages.

Problem:
1. As hardware becoming increasingly diverse, it is hard to optimize the OS for general purposes.
2. Current shared memory architecture does not scale well when the number of cores becomes large.

Contributions:
1. Proposed the multikernel architecture, which treats each processor as an independent component, and coordinate them like a distributed system. This can simplify the design of both hardware and the OS, as every CPU can ignore the existence of other CPUs, which eliminates the need for hardware cache-coherence; OS no longer need to worry about many (possibly heterogeneous) cores.
2. Making inter-core communications explicit. By doing this we can get rid of the shared-memory architecture and implement more efficient and scalable cache-coherent protocols via message passing in the OS level.
3. Making OS structure hardware-neutral. This can ease the engineering of OS when hardware changes.
4. Replicating OS state. Again this will help improve scalability.

Evaluation: The authors evaluated their system by running some sample workloads on Barrelfish and they achieved "reasonable" results. It would be best if they also compare their power consumption because energy efficiency is one of the most important factor in a modern data center.

Confusions:
1. The authors mentioned that the current OS architecture cannot scale to hundreds or more processors. However the trend today is to use a lot of cheap computers to build a distributed system, and therefore an OS will only need to manage a cheap computer which does not have that many cores. How is multikernel promising given this situation?
2. The authors mentioned that OS should be neutral to hardware. What is a recent example in which an OS kernel has to make a major change because of new hardware?

Summary:
The paper talks on developing an OS architecture named Multikernel, which would scale well with respect to the increasing number of cores in a system and which is flexible i.e., irrespective of the continuously evolving hardware the OS would still work without much modifications. Multikernel achieves its objective by looking at the multicore system like a distributed system and extends their well defined concepts such as replication, message passing communication to the Multikernel OS.

Problem:
OS were needed to be constantly modified for each type of architecture, as different optimizations were required on the different kinds of hardware and different hardware provide different kind of interfaces. Many of the existing OS were either too tightly coupled with the hardware or were not scalable to multi-core processors. Multikernel tries to solve this problem.

Contributions:
The paper provides an implementation of the Multikernel OS named Barrelfish. It looks at the multiprocessor like a distributed system. The OS tries to improve the performance in communication between multiple processes running on different cores by moving away from the shared memory communication to a message passing mechanism just like in distributed system. The reason being that in case of a shared memory, there is lot of waste of time in synchronization.

The OS also moves away from cache coherent model to a replicated model where each core maintains its own replica of state. This way the cores don’t have to wait for each other and the consistent of the replica could be obtained through message passing.

Evaluations:
Barrelfish evaluates its implementation on different multi-core machines to prove it is hardware neutral. They also provide an evaluation of the latency between using a shared memory and the message passing. Though the question still exists how well would the Barrelfish perform as compared to an OS which has been highly optimized for a specific hardware.

Confusions:
Could you talk more on what exactly is the role of a dispatcher mentioned in this paper? Is it possible to do away with dispatchers. It seems like there a dispatcher for a particular process on every core. Is the dispatcher processor specific or is it process specific?

Summary:
This paper introduces Multikerenel, a new OS architecture aimed at providing OS scalability and support for future hardware which are assumed to be networked, heterogeneous and dynamic. The paper treats Multikerenel as a distributed system that uses explicit message passing between its nodes rather than a centralized system that needs to be scaled to the network. The authors also describe their implementation of Multikernel, called Barrelfish and present an eveluation of Barrelfish.

Problem:
The authors observe that the current computer hardware is changing dynamically and at a pace greater than operating systems. The authors are of the opinion that the conventional OS is built around the coherent memory shared with a limited number of homogeneous processors and is not suitable for managing scale of the future hardware, which is expected to be largely heterogeneous. The authors also think that the shared memory in the current systems present a huge obstacle for OS scalability.

Contributions:
The biggest contribution of this paper is its application of insights from distributed systems to address the scalability and diversity issues in future operating systems. The paper reimagines the OS as a distributed system of functional units communicating via explicit message passing. The resulting Multikernel OS is based on design principles of making the OS hardware agnostic, inter core commnications explicit and most importantly replacing shared state with replicated state. In order to materialize this, multikerenel runs an OS instance on each core, with different instances on different cores communicating via explicit messages. An OS instance distinguishes between CPU driver, that provides privileged mode and monitor that facilitates user mode. CPU drivers are architecture specific and facilitates access to the underlying hardware, whereas monitors are hardware agnostic and collectively coordinate system wide state and encapsulates much of the mechanism and policies. The process is redefined as a collection of dispatcher objects, one for each core that it executes on. Inter core communication is through cache coherence and uses user level RPC between cores. Memory management is completely at the liberty of user level code.

Evaluation:
The authors present an extensive evaluation of Barrelfish and use x86_64 based hardware for their evaluation. The evaluation using microbenchmarks suggest that Barrelfish scales well with the core count. Barrelfish is also pitted against Linux for compute bound workloads such as OpenMP and SPLASH. These results show that Barrelfish does not scale particularly well. The authors opine that this might be because of user space libraries.

Confusions:
I still don’t buy into the idea of completely bypassing the cache coherence in hardware. Won’t this compromise the performance of the system?

Summary:
The author describes a new operating system structure – Multikernel. Author's main goal is improve scalability of operating system targeted for heterogeneous core systems. He treats machine as distributed system with different kernels running on top of each core which communicates with message passing protocols. Author describes one of the way of implementing Multikernel operating system – Barrelfish and shows how it's results are comparable with Linux under different workloads and promises to scale better to support future hardware.

Problem:
Hardware is changing and diversifying faster than system software which makes optimizing operating system for changing hardware difficult. Author claims with increasing number of cores, communication between cores via shared memory will not be efficient.

Contributions:
1. Main contribution of this paper is new distributed form of operating system in which different kernels runs on each core. For inter-core communications message passing is used instead of shared memory as experiments shows shared memory is not efficient in case of large number of cores.
2. OS on each core is structured as CPU driver which is kernel mode of operating system and user mode monitor process. CPU driver is responsible for protection and scheduling and has device specific code while monitors is hardware independent code which is responsible for inter core communication.
3. System knowledge base is maintained which is hardware specific information and OS can use it to optimize specific hardware on run time.

Evaluation:
Detailed evaluation of Barrelfish is presented by running it on different Intel and AMD machines under various workloads. Performance of Barrelfish which was not yet fully optimized and promised scalability was still comparable with conventional operating system. TLB invalidation was used to compare performance and they proposed SKB can be used to improve performance. Further, page unmapping operating is used to compare performance and performance was better than linux and windows.

Confusions:
What are revoke and retype operations in memory management?

1. Summary
This paper presented the idea of designing multicore operating system as a network of independent cores, using message-based inter-core communication, to tackle the scability problem of modern operating systems. A prototype “Barrelfish” is implemented to demostrate the feasibility of the idea, and to evaluate the performance against existing commodity operating systems.

2. Problem
Multicore processors are getting increasingly common in contemporary computers, and a series of problems occur under such circumstances:
1. The increasing diversity of hardwares makes it difficult for OS designs to exploit their features, leading to underperformed systems.
2. The increasing core heterogeneity and more programmable peripherals created difficulties for operating systems to manage. They cannot share a single OS kernel due to different instruction set architectures or performance issues.
3. Message-passing is becoming more popular in modern hardwares, and system softwares should adapt to the inter-core topology.
4. Asynchronous message-based communication is lightweight as there is no queuing delay and stalling on cache misses, would be more suitable for large scale systems.
5. As the number of cores increases, the growing complexity brings along expensive cache coherence protocols.
6. With discoveries in other domains, such as networks and distributed systems, it is getting easier to use messages in operating systems.

3. Contributions
This paper designed the multikernel OS model for modern multi-core machines. The multikernel model has the following characteristics:
1. All inter-core communications are explicit. In this way, networking optimizations could be deployed to improve the efficiency of interconnect. Besides, using asynchronous message passing methods for inter-core communication, the cores could do more useful work while waiting for a response. It is also easier for analysis since the message-passing system is naturally modular.
2. The operating system structure is hardware-neutral. Therefore, it is not so complex to run the operating system on new hardwares. The distributed communication algorithms are isolated from the hardware implementation or memory layout. Also, late binding of the protocol implementation and message transport is allowed, providing more flexibility for different workload scenarios.
3. Operating system states are replicated across cores instead of existing as shared data structures. The choice of replication over sharing memory makes it easier to preserve OS structure and algorithms while the underlying hardware evolves. Secondly, changes to running cores in an OS is allowed with replication. And potential optimization is that a replica of system state could be shared among a group of cores.

4. Evaluation
Based on the ideas above, the paper implemented an OS prototype with the multikernel model - Barrelfish, to evaluate the feasibility and performance of the multikernel operating system. Each core has an OS instance, divided into a CPU driver and a monitor. A region of shared memory is used as a channel to transfer messages for inter-core communication. For memory management, Barrelfish adopts capability model for in-memory objects. The paper argues that it would be wrong to draw quantitative conclusions from the benchmarks, though the tests show Barrelfish is very scalable and adaptable to more efficient communication patterns.

5. Confusion
1. What is one-phase commit operation? and two-phase commit operation?
2. I don’t quite understand the “two principle concerns” mentioned in 2.6 about message passing model.

1. Summary
The authors present a model of an OS that is architecture-independent and hence is scalable for the then upcoming era of multicore processors. This way a multicore system turns into a distributed system with explicit messaging through the interconnects. The authors also have implemented a version of this OS called Barrelfish.

2. Problem
With the computer hardware changing faster than system software, implementing a generic OS that works efficiently on all diverse hardwares is far-fetched. Also, with multicore systems and non-uniform memory architectures, a single OS cannot take advantage of the individual features of the hardware. In fact, it might be slower on non-uniform architectures. With cache lines increasing, more cores contend for the same line which slow the execution as a whole. Message passing is advantageous in situations like this and the multi kernel can form a communication network between the cores using message passing.

3. Contributions
a) Since there is one instance of an OS running on every core, messages between cores are made explicit. This makes it easy to debug and write an OS that is efficient since we do not have to worry about the interconnect network structure of the hardware.
b) Since the OS does not have to worry about how the hardware components are ties together, it becomes hardware-neutral and is thus easy to scale across processors.
c) With an instance of OS running on each core, the states of the OS such as dispatcher, scheduler have to be replicated across the instances thus making them independent of the other OSes. Thus the cores are event-driven rather than waiting for a coherent system response.
d) The OS comprises of a CPU driver that runs in kernel space that adheres to the hardware it sits on and a Monitor that runs in user space and takes care of communication between the cores through user-level RPCs.
e) The CPU driver handles the protection, time-slicing processes and authorisation. Each process is broken into a bunch of dispatches objects that are scheduled by the CPU driver.
f) Memory management is primarily done by the user level process by acquiring capabilities. Global memory allocation has to be communicated through the monitors so as to preserve atomicity of data.

4. Evaluation
With the separation of a global OS for a multicore system, any data that has to be maintained globally is an issue. Clearing TLBs and unmapping pages prove to be promising in the Barrelfish OS in a system with cores greater than 12. Since messages are pipelined and sent from every individual core, they are generally faster compared to the normal sequential transfer of messages from each core. This holds true even for parallel processing operations using OpenMP. Thus, on the whole, Barrelfish proves to be promising in a system with a large number of cores.

5. Confusions
The CPU driver has to accustom the OS to every known hardware. Doesn’t this mean a lot of driver code goes into that section and it would be too large compared to any traditional OS?

1. Summary
This paper investigates and presents an implementation of a new OS structure, the multikernel. The machine is treated as a distributed system that communicates using message passing instead of a monolith composed of a diverse set of cores and hardware.
2. Problem
Systems in use today have a increasing number of cores and those cores are becoming more varied in capability and required optimizations. The model of a monolithic kernel running with shared memory is difficult to scale, a problem the authors hope to solve by restructuring it into a multikernel.
3. Contributions
Cores in a system are treated as a group of distributed nodes, with interprocess communication handled by a core monitor which is decoupled from the core "driver" that handles the lowest level work.

The core monitor handles replication of state across cores which is meant to increase reliability and reduce the amount of overhead incurred by fetches over the interconnect between cores. The monitor also handles message passing between cores, which in the case of Barrelfish took place in the form of RPC. To keep state consistent between cores a multicast network is used; it is generated on startup based on system knowledge.

Memory management is handled by a capability system, where capabilities are user level references to kernel objects or physical memory. Shared memory is handled with a mechanism that allows user level code to share capabilities among cores.
4. Evaluation
The authors of this paper evaluated it on several different multicore devices with different physical sets of interconnects between cores. They evaluated the inter-core RPC performace by implementing a loopback interface that communicated between cores using it and compared it to the Linux implementation. They also evaluated compute bound workloads and found that Barrelfish performed comparably to Linux on them. Some tests, like the web server test seem like a non-comparison since they use lighthttpd on Linux to compare to an unspecified webserver running on Barrelfish. It's not clear what kind of features or overhead the presumably custom server they run has, which makes the fact that it's faster than lighthttpd somewhat meaningless.
5. Confusion
I was not sure exactly what "state" was counted as something the monitors had to keep consistent. It seemed to be virtual address tables + more?

1.Summary
This paper introduces the concept of multikernel OS, its design principles and implementation to explore the scalability of operating system on wide variety of hardware.

2. Problems
Hardware diversity is increasing fast and general-purpose operating system has challenges in accommodating with these future hardware. OS must perform well on an increasingly diverse range of system designs, which means such an OS cannot be optimized for any particular hardware configuration. The diversity of hardware impairs efficiency in designing and adapting system. However, operating systems are forced to adopt such optimization in order to be efficient on modern hardware.

3 . Contribution
This paper introduces the multikernel model and the design principles of
1. Explicit communication: Explicit communication allows the OS to deploy well-known networking optimization to make more efficient use of the interconnect, as well as provide isolation and resource management on heterogeneous cores. Finally, the explicit interface makes the system more easily to be evolved and refined.

2.Hardware-neutral structure: enables running OS on hardware requires no extensive changes to code base; can isolate the distributed communication algorithms from hardware implementation detail and enable late binding of both the protocol implementation and message transport.

3.State replication: can i,prove system scalabolity by reducing load on the system interconnect, contention for memoryand overhead for synchronization.

Presents a multikernel, Barrelfish, which explores the implications of applying the model to a concrete OS implementation;

Shows through measurement that Barrelfish satisfies goals of scalability and adaptability to hardware characteristics, while providing competitive performance on contemporary hardware.

4. Evaluation
While the multikernel is theoretically elegant, it is an idealist position.

The author evaluates the system with a detailed case study of TLB shootdown. The NUMA aware multicast scales extremely well across the 32-way system. What's more, the message-based unmap operation in Barrelfish outperforms some Linux and Windows servers. In the evaluation of compute-bound workloads, though benchmarks do not scale particularly well on either OS, at least demonstrate that despite its distributed structure, Barrelfish can still support large, shared-address space parallel code with little performance penalty. In I/O evaluation, Barrelfish gains performance by running entirely in user space and communication over URPC. Generally, the evaluation manifests the advantages of Barrelfish over traditional OSes. Multikernel better match to the underlying hardware and allow us to apply insights from distributed systems to the problems of scale, adaptivity and diversity in operating systems for future hardware, though evaluation in paper is not a very through comparison between Barrelfish and others.

5. Confusion
From the paper of Opal, shared memory access has the advantage of protection, which isn't referred here. What's the protection capability in multikernel?

Summary
This paper presents BarrelFish, which is operating system one doesn’t use shared memory and instead uses a distributed model to communicate messages between each core. The goal of the paper was to develop a scalable multikernel, which replicates the state of the kernel across each core and uses a message based system to communicate between cores.

Problem
The motivation behind this restructuring is that current general purpose systems that use shared memory to communicate do not scale well as more cores are added. Therefore, in order to create an operating system that can scale efficiently as the number of cores scales, it is necessary to restructure the kernel into a multikernel to take full advantage of the hardware provided.

Contributions
The main contributions of this paper were to restructure the kernel into a multikernel model. In the multikernel model, all communication between cores is explicit, the OS structure is hardware neutral, and the state of the kernel is replicated across all cores. The multikernel model borrows ideas from distributed systems and applies them to how the OS is structured. Because the machine can now be viewed as a network, many networking optimizations can be applied to the message system to make communication between processes even faster, such as pipelining. The OS structure in BarrelFish is also hardware neutral. In BarrelFish, the only parts of the OS that are hardware dependent are the CPU drivers and the devices. Because of this, the distributed communication between processes can be isolated from the hardware, allowing the system to scale to more cores. Additionally, each core has a local replicated view of the system state. Updates to the system state data structures are simply changed locally and consistent state is maintained between the other cores by sending messages.

Evaluation
The paper presents a case study of a TLB shootdown, which is when a core wishes to change a virtual page mapping. They found that a NUMA aware multicast of alerting the cores of the mapping to be removed was the most efficient algorithm in terms of latency as the number of cores scales for removing a page in the TLB. They also found that their message passing system similarity compared to systems that use shared memory to communicate. They also speculated that as the number of cores would increase, their system of message passing between cores would scale more favorable as compared to shared memory.

Confusions
If the role of the monitor is to optimally schedule processes running on its core, how does the system globally optimize the use of the cores? Is there some distributed algorithm that globally maintains the optimal utilization of all the cores?

1. Summary
In the paper "The multikernel: a new OS architecture for scalable multicore systems", the authors propose a multikernel that treats the machine as a network of independent cores. By viewing each core as a separate processing unit with its own state and using message-passing and various distributed-system protocols to manage consensus and sharing, the operating system can be generalized for the ever changing underlying hardware. The model not only allows the OS to benefit from the distributed systems approach to gain improved performance, support for hardware heterogeneity, greater modularity, but also provides the system developers the ability to reuse algorithms developed for distributed systems.

2. Problem
Rising core counts and increasing hardware diversity, both between cores within a machine, and between systems with varying interconnect topologies and performance trade-offs are the future hardware trends. Hence, it is no longer useful to tune a general-purpose OS design for a particular hardware model: the deployed hardware varies wildly, and optimizations become obsolete after a few years when new hardware arrives. Therefore,the OS structure should be decoupled from hardware as much as possible.

3. Contributions
- three design principles: (1) make all inter-core communication explicit, (2) make OS structure hardware-neutral, and (3) view state as replicated instead of shared
- using distributed system of monitors and their associated CPU drivers to mimic the functionality of a monolithic microkernel: scheduling, communication, and low-level resource allocation
- CPU drivers interface with the actual hardware while the monitors are user processes communicating between the applications and the CPU drivers
- modelling a process as a collection of dispatcher objects, one on each core on which it might execute thereby binding the interprocess communication to the communication between cores
- performing memory management through system calls that manipulate capabilities(similar to that in Hydra and Opal) which are user level references to kernel objects or regions of physical memory
- providing a service called system knowledge base to maintain a repository of information about the underlying hardware so that mechanisms appropriate to a core can be chosen
- sharing virtual address space by replicating the memory and maintaining consistency by message passing

4. Evaluation
The authors have evaluated their multikernel prototype - Barrelfish in terms of messaging latency and IO performance (throughput) for UDP and web based queries running on a relational database residing on another core. The results of Barrelfish have also been compared against Linux and Windows.

5. Confusions
- Can you explain how system knowledge base was implemented?
- The role of the dispatcher is not quite clear to me.

Summary:
The paper presents an OS model for future multicore processors where the effects of heterogeneity of processors, inter-core-networking, I/O etc, are substantial. An implementation of the multi-kernel model, Barrelfish, is presented, highlighting the realization of key design principles, and compared against Linux and Windows OS.

Problem/aim:
The authors' aim was to develop an OS structure for future multi-core hardware, in which the inter-core sharing would have significant overheads due to the distributed nature of cores. Also, the CPU cores would be diverse so a monolithic kernel wouldn’t be efficient. Optimizations for one hardware wouldn’t be applicable to the next because of different architectures.

Contributions:
I think that the most significant contribution of the paper is that the authors predict that future multi-core processors which wouldn’t provide fetures like cache coherence due to overheads, which would be impractical considering performance. They suggest an alternative method of messaging for inter-core communication. The inclusion of state in the messages adds significant overhead, which is amortized through pipelining and batching. The authors propose to isolate message transport mechanism hardware and algorithms, which realizes the microkernel concept. To overcome the absence of shared memory in future systems, the authors propose replication of state among cores, coordinated through messages. But as mentioned in the paper, this restricts the ability the take advantage of hardware, such as L2 caches. An implementation model is provided in which the concepts and design principles proposed are realized. The concept of exokernel is realized by providing per core CPU drivers in the kernel space, which multiplex hardware and provide protection, and monitors, in the user space, which provide the policies and mechanisms for IPC, access to global state, signaling etc. The receiver polling on the last word of the cache line, which a sender is writing to, I think, is an implementationn of the event-driven system where the receiver waits for the message.

Evaluation:
The authors provide various case studies to compare the prototype of multi-kernel model, Barrelfish, against Linux and Windows. Firstly, they consider ‘TLB shootdown’ to highlight the performance of the ‘messaging’ approach along with SKB. Different protocols are considered and it is shown how hardware knowledge can be used to optimize for performance in multikernels. Unmapping is considered next and the graph clearly indicates that Barrelfish performs better than Linux and windows. Different workloads have been considered to compare the performance of Barrelfish against Linux and convincing graphs indicate that it performs equally well along with providing scalability.

Confusions:
Which layer does message transport belong to, is it in the kernel layer or the hardware? Why are the updates to replicated states exposed in the API? Shouldn’t the update happen at the control of the kernel to maintain consistency? How do the retype and revoke operations mentioned under Memory Management work?

Summary:
This paper introduces the concept of multikernel — a restructuring of the operating system model. The authors want to imagine OS as a distributed system consisting of many modules which can communicate via messages. They aim to make OS structure hardware neutral thus enabling better functionality over a system with a diverse mix of cores, caches, IO devices. The author also implemented a prototype multikernel called Barrelfish and evaluated its performance in terms of scalability and adaptability.

Problem:
Modern systems are being developed containing multiple processor cores and diverse architecture but it is very inefficient to statically modify prevailing operating systems to optimize them for all these hardware variants. The paper claims that these optimizations will become obsolete once the hardware changes with time. The authors also claim that there are scalability issues for cache coherent shared memory even on smaller number of cores.

Contribution:
This paper provides us with a new model for designing operating systems — multikernel which can persist over rising core counts and increasing hardware diversity. The author also favored messages as a mode of communication rather than modifying shared memory to deal with its limitations. All inter core communication was to be made explicit and OS states to be replicated rather than sharing. The machine is viewed as a network and OS as a distributed system and any shared state is accessed and updated as a local copy. Replicating data structures improved scalability by reducing load on system interconnect, contention for memory and overhead for synchronization.

Evaluation:
The authors implemented an OS called Barrelfish based on the design philosophies of multikernel over Intel and AMD processor cores. However the inter-core communications were done using a region of shared memory as a channel to transfer messages. The performance measurements also do not truly reflect the actual performance of multikernel as their implementation was done over homogenous Intel and AMD processors. The message protocol also suffered anomalies due to the effect of queue lengths. The authors also claim that Barrelfish’s complete message based unmap operation performed better than IPI based operations in Linux and Windows.

Confusions:
I was unable to understand what performance optimizations are lost because of using messages. The example provided was L2 shared caches between cores.

Summary:
The paper proposes the multikernel architecture for operating systems, which uses the concepts from distributed systems to handle diverse hardware architecture at scale and in networked system. The concepts are further evaluated using a basic implementation of core features.

Problem:
The increasingly networked nature of machine with multicore hardware, poses the problem of redefining OS architecture to accommodate most workloads and hardware variants in the system, for which it is difficult to statically optimize an OS.

Solution:
Paper proposes a new OS structure that treats machine as a network of independent cores, moving OS functionality to a distributed system of processes that communicate via message-passing. Some important features are:
-message-based sharing, no memory sharing: making inter-core communication explicit
-replicated state: no memory sharing between cores means that the machine states needs to be replicated across cores.

Evaluation:
Extensive evaluation is done using test cases like IP loopback and polling to show the validity of Barrelfish, but as accepted in the paper it's difficult to compare it with large scale deployments of current systems.

Learning/Confusions:
-It would be good to have a discussion in class on state replication, best practices for sharing the data in multikernel and shared-memory based OS environment.

Summary :
This paper presents the idea of viewing an operating system with multiple cores as a distributed system, providing scalability through replication. The authors present the implementation details of BarrelFish, the multi kernel Operating system focussing on separating OS structure from hardware for extensibility.

Problem :
When operating systems are statically optimized for certain workloads and hardware variants, it is very difficult to meet dynamically changing workloads, which are very common in current scenario. So, the best solution would be to view the operating system architecture as a network of inter connected cores just like individual nodes in a distributed system. Also, tuning a general purpose OS design for a particular hardware model is bad because of the heterogenous hardware available currently and the possibility of the optimizations growing obsolete. So, the OS structure should be decoupled from hardware as much as possible.

Contributions :
1. The idea of treating the cores in a single system as a distributed system of nodes and defining the inter process communication explicitly decoupling it from hardware.
2. Using the mechanism of replication to access state across cores to reduce overhead of the interconnect and process communication thus making the system stable.
3. Using a nucleus kind of model where the CPU drivers schedule dispatcher objects which in turn manage different threads of the processes. Each process has its own dispatcher for each core.
4. Using monitors to maintain consistency among the replicas across the cores and also to facilitate message passing among threads across cores.
5. Using capability-model like Hydra for memory management. Capability here is a reference object in the kernel which a process can get access to.
6. The ability to share address spaces can happen by sharing capability objects, which happens through the monitors. Migration of threads across cores is also possible.

Evaluation :
The paper presents a lot of evaluation where their implementation is compared with other OSes. It can be seen that their system is very scalable in the number of cores. The system can also run well on heterogeneous hardwares. The authors say that sharing virtual space can be better if the hardware page table is shared among dispatchers rather than replicating it. There are also a lot of evaluation graphs showing how Barrelfish compares to Linux with various workloads. And they almost had comparable performance as the number of cores were increased to up to 16.

What I found confusing :
I am slightly confused about how they made shared memory processes work.

1. Summary
This paper presents a scalable operating system architecture designed for multi processor systems which consists of a minimal version of a kernel running on each processor. The authors take inspiration from distributed systems and apply similar design principles within a single machine.

2. Problem
The existing operating system designs are mostly for single processor systems. However, heterogeneous multi processor systems are increasingly becoming popular. This paper tackles the problem of designing a new operating system for the multi processor systems.

3. Contributions
The susbtantial contribution of this paper is the multikernel operating system architecture and its implementation - Barrelfish. The paper presents the key ideas of the multikernel approach in detail. It borrows some of the ideas from networks and distributed systems. The authors argue that communicating between different processors is most efficient via messages. They also mention that the operating system is neutral to the underlying hardware. And, instead of sharing, state is replicated at each processor to reduce the latency of accessing it. Barrelfish is an implementation of these design principles as a proof of concept. The operating system code is split into monitors and CPU drivers in Barrelfish. The CPU driver runs in kernel mode and interacts with the underlying hardware. The monitor runs in user mode and forms the interface between applications and operating system and handles communicaton.

4. Evaluation
The authors have run a lot of tests on Barrelfish to make sure all the goals of the multikernel operating system are met. They test parameters like message latency, CPU performance and I/O performance thoroughly. Comparison of Barrelfish with Windows and Linux variants are also presented.

5. Confusion
The paper mentions that any shared state among CPUs is accessed and updated as if it is a local replica. If the state is shared to begin with, isn't message passing after any update redundant? Also, I did not clearly understand what the system knowledge base(SKB) is and how is it implemented.

Paper: The Multikernel: A new OS architecture for scalable multicore systems

Summary:
The authors present a new OS structure, the multikernel that treats machine as a network of independent cores, and makes no assumption of underlying shared resources. The paper argues for rethinking the structure of OS as a distributed system also describe an experimental OS based on multikernel model - Barrelfish and discusses how it meets the performance goals.

Problem:
Computer hardware is changing and diversifying faster than system software and this leads to substantial scalability and correctness challenges for OS designers. The author also claims that with large number of cores, interconnect between them will be a subject of many of the same problem we face in networks and in addition, large number of cores will make cache coherency expensive and make it more difficult to provide the shared-memory abstraction.

Contributions:
The authors main contribution is a multikernel model that applies insights from distributed systems to the problems of scale, adaptivity and diversity in OS for future hardware. The model is guided by following three principles:
(i) message passing instead of shared memory provides better n/w optimization (pipelining, batching), isolation, better resource management and efficient scheduling
(ii) make OS structure hardware-neutral
(iii) replication: improves scalability by reducing load on system interconnect, lesser memory contention, synchronization overhead and lower latency.

Evaluations
The authors evaluate the performance of Barrelfish running on x86-64-based multiprocessors. The author starts with a detailed case study of TLB invalidation — which is simple, latency critical operation in a multiprocessor OS that requires global coordination. Latency of TLB shootdown is measured and compared with conventional OS for four URPC-based protocols. Results show that message passing paradigm is slower than shared memory for lower core counts and faster when the core counts increases. The performance of Compute-bound workloads and IO workloads is identical to those of conventional OS which is mostly due to user-space threads library.

Confusions
I didn’t quite get the implication of split phase nature mentioned in the paper.

Summary:
The paper makes the case for a multikernel OS structure, in which each kernel sits on top its core in a distributed fashion and communicates with the other kernels via explicit message passing. The authors present Barrelfish, a prototype based on this model, with details on the implementation of the process structure, memory management and communication. A performance case study is given to show how Barrelfish fares better than commercial OSs in terms of scalability and adaptability.

Problem:
With computer hardware evolving faster than its software counterparts, a range of different cores, caches and interconnect links make it harder to optimize, adapt and scale a monolithic OS with the ever changing underlying architecture. With the number of cores growing in modern systems, cache coherence schemes do not scale well and hence a more efficient form of inter-core communication is required.

Contributions:
1. The design of the multikernel structure is such that it minimizes its hardware dependence, by only having to deal with interconnects and cpus, which allows it to easily adapt without requiring huge changes in the codebase.

2. An explicit message passing system solves the problem of scaling hardware cache coherence by getting rid of shared memory almost altogether, except for the message channels. It also aids in making the entire system more modular in which network optimizations are more easier to perform.

3. Replicating data across cores improves latency times since cores can process on data local to them. It also reduces the overhead of synchronization found in a sharing kernel structures.

Evaluation:
The authors evaluate their multikernel model by performance analysis on the prototype Barrelfish built on intel and amd multicores. They give the rationale for their choice of messaging protocol by showing how the hardware optimized NUMA protocol better than other protocols in terms of latency. A case study for the TLB shootdown operation is given to show how Barrelfish’s unmap implementation despite having messaging overheads scales better than the current Linux and Windows IPI based implementations for multiple cores. On other compute based and IO based workloads the performance of Barrelfish is shown to be comparable to Linux.

Confusions:
Can you please expand on how exactly do the monitors keep the system wide state consistent?

1. Summary
This article describes the design and evaluation of the Multikernel, an OS architecture designed for scalability across diverse hardware. The Multikernel reimagines the OS as a distributed system of nodes communicating via explicit messaging. An implementation of the Multi-kernel is presented and evaluated for a range of workloads - the performance is comparable to conventional OSs, but their architecture is expected to scale better to higher core counts.


2. Problem
Nowadays general-purpose computers are having increasingly diverse hardware architectures in terms of CPUs, GPUs, interconnects etc. Optimizing a monolithic OS for such diverse systems is becoming increasingly difficult and may become impossible in the future. The authors consider the usage of shared memory kernel-structures to be the primary obstacle for OS scalability. In this paper they investigate an architecture that tries to completely avoid shared state.

3. Contributions
The multikernel model posits an independent OS node running on each core. This OS node is largely HW-neutral and views OS state as replicated instead of shared. The replicated state is modified through explicit inter-core communication through agreed-upon protocols. Communication uses message-passing, which is shown to be faster than shared memory for higher core-counts, mainly due to cache coherence overheads in shared memory. The only aspects of the OS that are HW-dependent are the interfaces to HW as well as message transport mechanisms. This eases scalability across heterogeneous processors and isolates the portions of the OS that could be optimized for individual architectures. Barrelfish, a prototype of this model, implements the OS instance on each core as a privileged CPU-driver and a user-space monitor. The CPU driver is HW specific and provides minimal functionality for protection, authorization, CPU virtualization etc. The monitor is a mostly HW-agnostic process that coordinates with rest of the system and provides most of the functionality of a conventional rich-OS.

4. Evaluation
TLB invalidation is a common workload that requires inter-core communication. They compare the latency of this operation against conventional OSs, for a variety of transport protocols. While the message-passing paradigm is slower than shared memory for smaller core counts, we find that it is faster than shared memory for larger core counts. They evaluate this system against common compute-bound and IO-bound workloads. In general, the multikernel performs comparably to existing OSs. Despite using microbenchmarks, there is sufficient empirical evidence to suggest the viability of this approach.

5. Confusions
How will an application use shared-memory on top of a multi-kernel system?
The role of the dispatcher and how it interacts with the monitor is not clear.

1. Summary
The current paper proposes a new distributed OS structure that treats a machine as a network of independent cores communicating with each other through message passing. This design primarily addresses the scalability issues of the current operating systems
2. Problem
Due to the diverse nature of the hardware (either because of new hardware features or heterogeneity), it gets difficult to tune a general purpose operating system for performance. The primary problem here is the scalability issue of shared memory system and overhead of maintaining cache coherency. The interconnect topology also is getting more favourable for message passing systems. Scaling the current OS design to efficiently adapt to these rapidly changing architectures requires a rethinking of the fundamental shared memory design.
3. Contributions
The authors propose a restructured OS architecture, Microkernel, that explores the distributed nature of a multicore system. In the new system, all the inter-core communication is performed through message passing and does not involve sharing memory. The OS structure is separated from the underlying hardware, with minimal dependence on the architecture. The global state is replicated rather than shared across processors.
Each OS instance has a privileged CPU-driver and a user mode monitor process. The CPU driver handles protection, capability authorization, process scheduling and provides hardware interface. The monitor handles the inter-core communication. One of the major challenges for memory management is to protect and maintain a consistent state across the system. The authors use capabilities to accomplish this. Monitors and capabilities together provide a system for managing global coordination. The authors also propose a System Knowledge Base that maintains hardware architecture information, which enables the OS to perform hardware specific design optimizations.
4. Evaluation
The authors provide an experimental evaluation on x86-64 based multiprocessors. I think the evaluation is an extensive one, highlighting the strengths deficiencies of the system. The system performs and scales well for microbenchmarks that take advantage of the message passing interface, while removing overheads of coherence. For CPU and I/O workloads, the system does not scale well and provides the same performance as a linux system. This was mainly because of performance issues with the user level libraries.
5. Confusion
Who decides where a user application runs? I did not understand, without a global control (like a server) how do you manage resources globally (like power management etc).

Summary

Computer hardware is evolving faster than computer software. One notable recent trend is the adoption of many-core systems, which exploit parallelism to achieve large performance gains. The authors propose a multikernel, which treats a single computer like a distributed system that uses message-passing as the dominant model for interprocess communication.

Problem

The rapid increase in number of cores used in modern computer hardware creates challenge in scalability and correctness. This is most notable with interprocess communications: modern operating systems typically rely on shared memory, which does not scale well. Moreover, modern operating systems are expected to run on a very wide variety of hardware configurations, and is difficult for a single system to adapt accordingly.

Contributions

The main contribution of this paper is the microkernel; in particular, the design concept of treating computer hardware like a distributed system. This plays out in several ways, notably message passing over shared memory and system state replication across all cores. The microkernel is also intended to be hardware independent, and highly scalable to a large number of cores. These new architectural designs are implemented into a new operating system, Barrelfish.

Evaluation

The authors present detailed evaluation of their Barrelfish operating system on a variety of different workloads. They meet their stated goal of having comparable performance to current operating systems, despite being a young and non-optimized system. One important limitation of these evaluations is that they are limited to moden hardware (maximum 32 cores) and are not able to test it on the very large number of cores we will likely see in the near future. Also, due to the complex nature of designing an operating system from scratch, their system is not fully mature and could be further optimized, although we cannot tell to what extent.

Confusions

I'm confused by view state replication -- what exact state are they referring to, and why is it needed on a multicore system?

Summary: This paper proposes multikernel, which treats the single machine as a network between independent cores. The cores share nothing at the lowest level. The OS is a distributed systems of processes communicating via message-passing. They implement a multikernel OS and the evaluation shows the performance is comparable with conventional OS.

Problem: As the hardware (cores, caches, interconnect links, and IO devices) changes and diversifies, the software usually need several years to reflect the changes. The basic obstacle is the shared-memory based OS. The message based method makes each core independent, thus allows heterogeneous dynamic OS.

Contribution:
1. It makes inter-core communication explicit messages, no memory is shared among cores except the message channels. This is good because the message passing is cheaper and cheaper in hardware level, it allows network optimization within a single machine, it isolates each core, more interpretable by human.

2. It separates the OS structure as much as possible from the hardware, only message transportation and the interface to hardware are for specific architectures. The benefit is: changing on hardware will not necessarily make change on OS, messaging system depends heavily on hardware and can be frequently changed.

3. Because all sharing info are by messages. The system states (e.g. linux scheduler queues) are replicated to be shared by cores. Replication may be better than shared states because it reduces the load (e.g. sync).

Evaluation: For the TLB shootdown case the multikernel system has higher latency than Windows/Linux, but the whole unmap latency is smaller when there is more than 12 cores. In two-phase commit multikernel achieves smaller latency. On 5 compute-bound workloads on 4x4-core AMD, multikernel achieves comparable results. In IO workloads performance is also comparable.

Confusion: I am confused about the performance comparison on read heavy computation workload, which shared-memory OS is good at.

1. Summary - The paper introduces Multikernel, which is a rethinking of OS architecture aimed to improve OS scalability and extensibility to support future heterogeneous and multicore systems. The authors also describe a first-cut implementation of this architecture, Barrelfish, and discuss its support for processes, inter-process communication and memory management.

2. Problem - The authors claim that the current design of operating systems as a shared memory kernel with synchronized access to protected data structures is inherently unscalable in terms of support for larger, heterogeneous systems. Also, conventional operating systems are tightly coupled to the underlying hardware, which limits the ability to adapt them for rapidly changing hardware architectures.

3. Contributions - The main contribution is the multikernel model with its design philosophy of explicit inter-core communication via message passing, hardware-invariance and replicated kernel state. Even more than their proposed model, I believe that the design guidelines of hardware-neutrality and replicated kernel state are more significant contributions from the point of view of upcoming heterogeneous systems. Their analysis of the issues that limit the scalability of current operating system designs for upcoming hardware is also important as they explore key factors such as the increasing diversity of cores and systems, the growing importance of interconnect, and the difficulty to support cache coherence with greater hardware complexity.

4. Evaluation - The authors evaluate the performance of this model using a relatively unoptimized implementation called Barrelfish running on various multicore Intel and AMD chips. The kernel operation of page unmapping is used to illustrate the performance of the message-passing protocol of Barrelfish as compared to the interprocessor interrupt based approaches found in Linux 2.6.26 and Windows Server 2008 R2 Beta. This operation incurs latency on Barrelfish comparable to these two commercial operating systems for small number of cores, and outperforms them on systems with more than 14 cores thus showing its superior scalability. The performance of several compute-bound workloads as well as IO workloads like relational databases is similar on Barrelfish and Linux. However, the authors claim that the performance of Barrelfish would be better once it is optimized as much as these commercial OSes.

5. Confusions - Could you talk briefly about event-driven programs? Do you agree with the authors' claim of the decreasing importance of cache coherence, even though Milo Martin and Mark Hill have been optimistic about the scalability of cache-coherence in their paper on 'Why on-chip cache coherence is here to stay'?

1. Summary
The authors describe Barrelfish, a multi-kernel operating system that aims to make operating systems more hardware neutral. Barrelfish is built like a distributed system of cores which communicate via message passing. This changes the way programmers may design multi-processor programs.

2. Problem
Operating systems are face with the challenge of performing optimally on a diverse set of hardware platforms. The authors note that the current design of operating systems may make them hard to adapt to differences in hardware. Adding the capabilities to exploit certain optimizations in certain hardware cases is difficult if the same OS is running in each case. In addition, with the rise of multi-processor systems, operating systems need to be increasingly aware of the exact details of the hardware they are operating on.

3. Contributions
The paper proposes Barrelfish, a distributed message-passing OS. By restructuring cores to pass messages, instead of sharing memory, the authors argue that they allow better control by the OS. The authors argue that the asynchronous programming is style is rather common and easy to reason about and a shift to that style would not be an impediment to programmers.

4. Evaluation
The authors provide quite a few graphs comparing their prototype operating system to other typical OSes. The data they present suggests that Barrelfish can run multi-process work loads about as well as current operating systems even though the benchmarks were not modified to take advantage of the message passing system. They also suggest, and demonstrate, how some operations like TLB shootdown can be optimized to scale better in a system like Barrelfish if the cores are not required to communicate over shared memory.

5. Confusion
I’m confused as to how they managed to make a shared memory process work as efficiently in Barrelfish as it would in Linux. Is it possible for monitors to allow shared memory access between cores? Or isn’t there some sort of overhead induced by the monitors if they are implementing the coherency themselves?