The EuroSys conference report blog

Automatically Patching Errors in Deployed Software [PDF]
Jeff H. Perkins (MIT), Sunghun Kim (HKUST), Sam Larsen (VMware), Saman Amarasinghe (MIT), Jonathan Bachrach (MIT), Michael Carbin (MIT), Carlos Pacheco (BCG), Frank Sherwood, Stelios Sidiroglou (MIT), Greg Sullivan (BAE AIT), Weng-Fai Wong (NUS), Yoav Zibin (Come2Play), Michael D. Ernst (U. of Washington), Martin Rinard (MIT)
—————————
1) Use Daikon to learn invariants
2) Use labeled correct and buggy runs to learn the violated invariants during attack
3) Force the learnt invariant

Q: What if it introduces a new silent bug?
A: That risks exist.

Detecting Large-Scale System Problems by Mining Console Logs [PDF]
Wei Xu (UC Berkeley), Ling Huang (Intel Research Berkeley), Armando Fox (UC Berkeley), David Patterson (UC Berkeley), Michael Jordan (UC Berkeley)
—————————
0) turn on the right logging level
1) Use the source code to understand the schema of the logs
2) Parse the log file
3) Look for anomalies

Q: How do you know what is the right logging level?
A: I Guess

Q: What if the bug does not show up after turning on a finer logging level?
A: no solution

FAWN: A Fast Array of Wimpy Nodes [PDF]
David G. Andersen (Carnegie Mellon University), Jason Franklin (Carnegie Mellon University), Michael Kaminsky (Intel Research Pittsburgh), Amar Phanishayee (Carnegie Mellon University), Lawrence Tan (Carnegie Mellon University), Vijay Vasudevan (Carnegie Mellon University)
—————————
In the interest of power, lets use an array of smaller machines which use less power
- The peak power in these machines is less

The CPUs has become much faster than the hard disks. Thus, we do not need fast big machines for IO-intensive tasks; small boxes would perform the same.

FAWN uses key-value schema to be easily parallelizable on several machines.

Challenge: flash disks do not perform well in small writes
- solution: use only append

RouteBricks: Exploiting Parallelism to Scale Software Routers [PDF]
Mihai Dobrescu (EPFL) and Norbert Egi (Lancaster University/Intel Research), Katerina Argyraki (EPFL), Byung-Gon Chun (Intel Research), Kevin Fall (Intel Research), Gianluca Iannaccone (Intel Research), Allan Knies (Intel Research), Maziar Manesh (Intel Research), Sylvia Ratnasamy (Intel Research)
—————————
Routers are either fast or programmable; Fast routers are hardware routers.

RouteBricks: get performance out of off-the-shelf PCs (software routers)

Each server represents a (few) line card with rate R.

Problem: Each server needs N.R processing power for switching (N is the number of interfaces)
Solution: Valiant load balancing: use intermediate servers, each server divides the output traffic between N intermediate server and then the intermediate servers aggregate the traffic towards the external interfaces.
=> Per-server processing rate = 3.R

Improve per server performance:
- write a device driver to batch several packets before sending them to cores

Uses one core per queue (having multi-queue interfaces)

The prototype has 4 servers.
- It introduces reordering: 0.15%
- Latency is *estimated* 24 microsecond per server

Q: programmability needs to keep states. Having your architecture distributed, how programmable it would be?
A: it is an issue

Q: power?
A: we spend more power

Q: if you actually program your router, the performance drops, no?
A: …

The Multikernel: A New OS Architecture for Scalable Multicore Systems [PDF]
Andrew Baumann (ETH Zurich), Paul Barham (MSR Cambridge), Pierre-Evariste Dagand (ENS Cachan Bretagne), Tim Harris (MSR Cambridge), Rebecca Isaacs (MSR Cambridge), Simon Peter (ETH Zurich), Timothy Roscoe (ETH Zurich), Adrian Schüpbach (ETH Zurich), Akhilesh Singhania (ETH Zurich)
—————————
System diversity: the cache model and interconnect is different from architecture to architecture
- can not optimise at design time

proposal: OS as distributed systems
- replicated state
- make the inter-core communication explicit

all communication with messages -> no shared data

use sharing just as a local optimization of message passing

performance is comparable to existing systems

Keynote: Barbara Liskov, ACM Turing Award Lecture
—————————
the Interdata 3:
- idea: first build a small machine (hw) them build a power machine on top of that (programs)
- I designed th instruction set and put semaphore in them

Software crisis:
- cheap machines and expensive programmers
- Dijkstra, The humble programmer, 1972

Programming methodology:

Dikstra: Go To Statement Considered Harmful, 1968
- Relation between static instructions and dynamic states
- The difficulty of debugging
- The need for structured programming: goto-less programming

Wirth: Program Development Stepwise Refinement, 1971
- Start from the top abstract level
- top-down process

Parna: Information Distribution Aspects of Design Methodology, 1971
Parnas: On the criteria to be used in decomposing systems into modules, 1972
- Modular programming

Liskov: A Design methodology for reliable software systems, 1972
- Break the entire system to partitions
- The states in each partition can be accessed by dedicated interfaces
- Similar in spirit to operating system design in which access to os data is limited

From Partitions to ADTs;
- Idea: connect partitions to data types

Extensible Languages:
- overreaction to a problem in programming languages
- syntactic & semantic extensibility
– syntactic: have new symbol for new concepts in program
– semantic: …

Dahl, Hoare: Hierachical Program Structures. Structured Programming, 1972
- Class and Sub-Classes

Morris: Protection in Programming Languages, 1973
- Importance of locality of data
- The encapsulation was expensive to enforce, though

Wulf and Shaw: Global Variable Considered Harmful, 1973

Liskov and Zilles: Programming with abstract data types
- A set of operations
- A set of objects
- operations are the only way to access the objects
- polymorphisms
- static type checking (we hoped)
- exception handling

From ADTs to CLU:
- The need for a programming language to enforce them

Goals:
- ease of use
- simplicity
- expressive power
- performance

Assumptions/Decisions:
- Heap-based with garbage collection!
- No block structure!
- Separate compilation
- Static type checking
- No concurrency
- No gotos
- no inheritance

CLU Mechanisms:
- Clusters: unlike OO, we considered operations for types not objects
- Polymorphisms: ???
- Exception Handling;
– Termination vs. Resumption
– How to specify handlers
- Iterators: it did not support nested iterators for the sake of efficiency in implementation

Type hierarchy:

At the time, inheritance was used both for implementation and type hierarchy

LSP: The Liskov Substitution principle
- objects of subtypes should behave like those of supertype if they are called via supertype methods

What next?
- modularity based on abstraction is the way thing are done

Modern Programming Languages:
- Are good!
- Serialization is not done well
- data types are changing over time, it is hard to program

The state of programming:
- The return of globals!
- Persistent storage violates the rules: files are like global variables

Performance is not the most important issue
- vs. Semantics
- vs. Simplicity

Massively parallel machines (many-cores) are actually distributed systems

FAWN: A Fast Array of Wimpy Nodes [PDF] David G. Andersen (Carnegie Mellon University), Jason Franklin (Carnegie Mellon University), Michael Kaminsky (Intel Research Pittsburgh), Amar Phanishayee (Carnegie Mellon University), Lawrence Tan (Carnegie Mellon University), Vijay Vasudevan (Carnegie Mellon University)

RouteBricks: Exploiting Parallelism to Scale Software Routers [PDF] Mihai Dobrescu (EPFL) and Norbert Egi (Lancaster University/Intel Research), Katerina Argyraki (EPFL), Byung-Gon Chun (Intel Research), Kevin Fall (Intel Research), Gianluca Iannaccone (Intel Research), Allan Knies (Intel Research), Maziar Manesh (Intel Research), Sylvia Ratnasamy (Intel Research)