{"id":120,"date":"2011-03-31T12:58:54","date_gmt":"2011-03-31T12:58:54","guid":{"rendered":"http:\/\/www.syslog.cl.cam.ac.uk\/?p=120"},"modified":"2011-03-31T20:28:12","modified_gmt":"2011-03-31T20:28:12","slug":"nsdi-2011-day-2-liveblog","status":"publish","type":"post","link":"https:\/\/www.syslog.cl.cam.ac.uk\/2011\/03\/31\/nsdi-2011-day-2-liveblog\/","title":{"rendered":"NSDI 2011 Day 2 LiveBlog"},"content":{"rendered":"

Hey all,<\/p>\n

Today's LiveBlog is even liver: Join us on IRC at chat.freenode.net, channel #nsdi11 (go here<\/a> for web IRC access).<\/p>\n

Bootstrapping Accountability in the Internet We Have<\/strong><\/p>\n

(9:01:51 AM) <\/span><\/span>smowton: Ang Li, Xin Liu and Xiaowei Yang
\n(9:02:04 AM) <\/span><\/span>malte: \"the internet was designed in the old time\"
\n(9:02:47 AM) <\/span><\/span>smowton: They're worried about \"traffic hijacking,\" defined as advertising prefixes you don't own
\n(9:02:48 AM) <\/span><\/span>malte: example: Pakistan YouTube incident
\n(9:02:59 AM) <\/span><\/span>smowton: and also plain old DDOS
\n(9:03:48 AM) <\/span><\/span>smowton: morning Theo
\n(9:03:52 AM) <\/span><\/span>twh25: afternoon!
\n(9:04:04 AM) <\/span><\/span>smowton: motivating example: Wikileaks supression
\n(9:04:12 AM) <\/span><\/span>malte: Attacks are bad: disruptive, politically motivated, costly
\n(9:05:26 AM) <\/span><\/span>malte: Largest DDoS attack observed in practice has exceeded 100 Gbps
\n(9:06:17 AM) <\/span><\/span>malte: Question: Can we make the intertubes secure?
\n(9:06:20 AM) <\/span><\/span>smowton: Challenge: secure the internet in a way that's incrementally deployable *and* helps early adopters
\n(9:07:13 AM) <\/span><\/span>smowton: previous work: secure BGP (BGP + signing)
\n(9:07:27 AM) <\/span><\/span>malte: There are various existing approaches: Secure BGP, packet source authentication
\n(9:07:41 AM) <\/span><\/span>malte: reference for the latter: \"Packet passport\" in NSDI 2008
\n(9:07:49 AM) <\/span><\/span>smowton: Other previous work: source-signing, in which packets contain unforgable source information to prevent spoofing
\n(9:08:11 AM) <\/span><\/span>smowton: Natural application to preventing DoS as you know who's actually doing it
\n(9:08:24 AM) <\/span><\/span>malte: What's missing? Why is the internet so vulnerable?
\n(9:09:24 AM) <\/span><\/span>malte: two types of \"natural identifiers\" in the internet: (1) IP addresses, (2) IP prefixes
\n(9:09:51 AM) <\/span><\/span>malte: but they cannot be used for accountability (\"identify bad guys\") because they can be spoofed, like all network-layer identifiers
\n(9:10:05 AM) <\/span><\/span>smowton1: they introduce \"IPA\", IP-made-accountable, which tries to produce non-spoofable network identifiers
\n(9:11:24 AM) <\/span><\/span>smowton1: Criticism of existing approaches:
\n(9:11:32 AM) <\/span><\/span>smowton1: PKIs require heavyweight deployment
\n(9:11:36 AM) <\/span><\/span>smowton1: web-of-trust isn't reliable
\n(9:11:44 AM) <\/span><\/span>smowton1: and self-signing has obvious problems
\n(9:13:05 AM) <\/span><\/span>smowton1: proposal: use DNSSEC and BGP to serve the role of a PKI
\n(9:14:16 AM) <\/span><\/span>smowton: In the case of DNSSEC, this means using a reverse-resolution record as proof of ownership of some IP range
\n(9:14:55 AM) <\/span><\/span>smowton: or rather, attesting to your owning a keypair that you will use to sign source addresses
\n(9:15:23 AM) <\/span><\/span>mas90: that's pretty cool. I bet the IETF would love that
\n(9:16:18 AM) <\/span><\/span>smowton: Apparently there's a break in the chain of trust between in-addr.arpa and root allocators like ARIN; just an administrative thing though
\n(9:16:55 AM) <\/span><\/span>smowton: the top-level guys would just assert ownership of some key, but presumably SSH-style has-the-key-changed will suffice for something so commonly encountered
\n(9:16:59 AM) <\/span><\/span>malte: (and supposedly to be resolved shortly: \"by end of March\")
\n(9:16:59 AM) <\/span><\/span>mas90: ha
\n(9:16:59 AM) <\/span><\/span>mas90: better be quick :)
\n(9:17:56 AM) <\/span><\/span>malte: certificate distribution is supposed to be \"in-band\", by piggy-backing on BGP announcements
\n(9:18:07 AM) <\/span><\/span>smowton: BGP messages enclose certificates in the obvious way, a la HTTPS supplying the complete cert chain
\n(9:18:19 AM) <\/span><\/span>malte: the data would go into \"optional\" and \"transitive\" path attributes
\n(9:18:34 AM) <\/span><\/span>smowton: the chain should mirror netblock delegation
\n(9:19:20 AM) <\/span><\/span>malte: Each certificate is ~650 bytes
\n(9:19:31 AM) <\/span><\/span>smowton: They're concerned about overhead, and solve it by sending only unsent certificates
\n(9:19:45 AM) <\/span><\/span>smowton: but really, how significant is the complete throughput of BGP relative to actual dataplane traffic?
\n(9:19:47 AM) <\/span><\/span>malte: in order to avoid sending those big-ish certs all over the place all the time, the certs relating to neighbours are cached
\n(9:20:07 AM) <\/span><\/span>malte: smowton: agreed
\n(9:20:41 AM) <\/span><\/span>smowton: cert revocation is done in the ordinary existing fashion: revocation lists (eagerly flooded to your delegatees) and expiry dates
\n(9:22:41 AM) <\/span><\/span>malte: eval in terms of three dimensions: performance, security and adoptability
\n(9:23:52 AM) <\/span><\/span>malte: for time's sake, they only present the overhead on normal BGP and some adoptability analysis in the talk
\n(9:24:35 AM) <\/span><\/span>malte: their BGP trace contains a total of 118M updates, with ~44 occuring per second
\n(9:25:08 AM) <\/span><\/span>smowton: they measure in terms of bytes\/second for a BGP speaker taking part in their protocol but otherwise exchanging the same updates as a real-world speaker
\n(9:25:36 AM) <\/span><\/span>smowton: they find some examples of updates that would take 60 seconds to process
\n(9:25:43 AM) <\/span><\/span>smowton: but 99.4% would be <= 30s
\n(9:26:06 AM) <\/span><\/span>smowton: presumably this would get better as routers are already expensive; could include some specialist crypto h\/w
\n(9:26:42 AM) <\/span><\/span>smowton: adpotability problem: there's a Cisco router that explodes when they set their cert attribugte
\n(9:26:53 AM) <\/span><\/span>smowton: mundane bug
\n(9:27:25 AM) <\/span><\/span>smowton: this is their incremental adpoptability: BGP speakers will preserve their new attributes even if they don't understand them themselves
\n(9:28:33 AM) <\/span><\/span>smowton: and that's that<\/p>\n

 <\/p>\n

Privad: Practical Privacy in Online Advertising<\/strong><\/p>\n

09:35 < malte> Next talk: Serving ads from localhost for Performance, Privacy and Profit
\n09:35 < malte> Saikat Guha, Microsoft Research India; Bin Cheng and Paul Francis, MPI-SWS
\n09:35 < avsm> woah cool, usenix is serving ipv6 dhcp!
\n09:36 < malte> experimental talk: he's going to keep the talk short and leave lots of time for questions
\n09:36 < malte> Today's web ads suck: quality sucks, so flood users with lots of them
\n09:36 < malte> loading ads from third-party servers slows down page rending
\n09:37 < malte> the way it works today is that a \"broker\" of some sort (e.g. Google) marries advertisers' ads to publisher websites
\n09:38 < malte> money flows from advertisers to brokers to publisers
\n09:38 < malte> users don't get a cent
\n09:38 < mas90> users are the saleable product :-)
\n09:39 < smowton> users get content :)
\n09:39 < malte> cookies leak information to ad broker -- Google knows every page we visit
\n09:39 < smowton> problem: persistent cookies as the broker domain is the same even if the site is different
\n09:40 < smowton> they're worried that an evil employee will sell the Google Ads database
\n09:40 < smowton> Goal: work in the current world
\n09:40 < malte> including \"the current click-fraud model\" :-)
\n09:41 < malte> they define privacy as \"unlinkability\"
\n09:41 < smowton> \"private enough\"
\n09:41 < smowton> keep the tracking-for-targeted-ads thing without letting anyone know who you are
\n09:42 < smowton> basically because otherwise only the altruistic advertisers will adopt
\n09:42 < malte> at the same time, they don't want to trade off privacy for poorer advert quality
\n09:42 < smowton> and there are obvious problems with that sentence :)
\n09:42 < smowton> \"Scalable: yada yada yada\"
\n09:43 < malte> fundamental decision: the most trusted entity in the advertising ecosystem is the client's own computer
\n09:44 < malte> they are wondering what data *needs* to leave the local system
\n09:44 < malte> they could achieve privacy by either having an anonymization network in between the user and the broker (e.g. Tor)
\n09:45 < malte> but the problem with that is that it doesn't allow detection of click fraud
\n09:45 < smowton> problem: most anonymisation protocols would make the ad-broker vulnerable to click fraud
\n09:45 < malte> so they introduce another party called the \"dealer\"
\n09:45 < malte> they assume that the dealer and the broker don't ever collude
\n09:46 < smowton> the dealer anonymises and filters for fraud
\n09:46 < smowton> the broker plays his old role but with anonymised input
\n09:46 < malte> the local agent monitors user behaviour and builds a local user profile
\n09:46 < smowton> why would anyone be a dealer?
\n09:47 < malte> broker sends a bunch of ads to the dealer, who then sub-selects the ones to present to the user
\n09:47 < malte> the agent has got a local cache of ads that is populated by the dealer
\n09:47 < malte> (question: how does the broker know that the ads have actually been viewed?)
\n09:48 < malte> (their solution is that the client reports ad event to the dealer, who reports to the broker... but that assumes that both agent and dealer are honest)
\n09:48 < smowton> the dealer seems like a vague creature; this basically moves the risk from the broker to the dealer
\n09:49 < smowton> ah, the ad reports are encrypted; the dealer can't peek
\n09:49 < malte> actually, they use PKI to sign the reports so that the dealer can't modify them
\n09:49 < smowton> assuming again he doesn't collaborate with the broker
\n09:49 < malte> it only strips the private information
\n09:49 < malte> *he
\n09:49 < smowton> which here == IP
\n09:50 < malte> now he's asking people what they want to know more about
\n09:52 < malte> Q: is the user profile information actually safe on the user's own machine?
\n09:52 < malte> A: probably more so than anywhere else...
\n09:53 < malte> Q: is this really compatible with the current ad model? Does it support CPI and CPC models?
\n09:54 < malte> A: Yes, all of view\/click\/other events can be reported through their ad event reporting system
\n09:55 < smowton> A: yup
\n09:55 < smowton> Q: why would a broker trust dealers to stay functional?
\n09:56 -!- googie [80e80ef5@gateway\/web\/freenode\/ip.128.232.14.245] has joined #nsdi11
\n09:57 < smowton> A: They can use the privacy benefits as a selling point
\n09:58 < smowton> but ad-vendors don't really sell to users
\n09:58 < smowton> I could see tinfoil-hat websites that desperately need ad revenue selling it to their user
\n09:58 < smowton> but pretty much only them
\n09:58 < smowton> Aside: they don't care about AdBlock: it works either way, and only 12% of people use them
\n09:59 < smowton> I'm actually surprised how high that figure is
\n09:59 < malte> indeed
\n09:59 < malte> looks like people in Saudi Arabi haven't been educated about spyware toolbars yet ;-) (40% install third-party tool bars)
\n10:00 < smowton> Q: why-t-f would you be a dealer? how will you make money?
\n10:00 < smowton> A: they won't; they'll be run as a public service by the EFF or someone like that
\n10:00 < smowton> Alternatively, MS could be both -- with appropriate legal oversight
\n10:01 < smowton> seems to me like the same deal as laws requiring them not to be evil in using their ad data
\n10:01 < smowton> I suppose so long as no one angry employee has the keys to the dealer's logs and the broker's logs also...
\n10:02 < malte> Q: How do you prove to me that the local agent tool (supplied by YOU) is not going to act as spyware and leak my data?
\n10:02 < smowton> ooooh, answered a question by \"removing the weasel words\"
\n10:02 < smowton> take that, wikipedia
\n10:03 < smowton> it's 10:03; the Usenix heavies are descending
\n10:05 < malte> opinion: nice talk as it was controversial and incited discussion, and the presenter is actually keen on this stuff
\n10:05 < malte> but I don't really buy the architecture
\n10:05 < smowton> yup same
\n10:05 < smowton> like most things, no incentive to improve without direct pressure from the users
\n10:06 < smowton> and most people don't know or care about the problem
\n10:06 < smowton> alright
\n10:06 < smowton> next talk<\/p>\n

Bazaar: Strengthening User Reputations in Online Marketplaces<\/strong><\/p>\n

(10:06:47 AM) <\/span><\/span>smowton: Ansley Post,\u00c2\u00a0MPI-SWS and Rice University;\u00c2\u00a0Vijit Shah and Alan Mislove,\u00c2\u00a0Northeastern University<\/span>
\n(10:07:21 AM) <\/span><\/span>smowton: Marketplaces are what you might suppose: eBay et al
\n(10:07:32 AM) <\/span><\/span>smowton: point being, untrusted people trading with others
\n(10:08:54 AM) <\/span><\/span>smowton: economists observe that your eBay reputation does matter
\n(10:09:00 AM) <\/span><\/span>smowton: you'll get more money for the same item
\n(10:09:06 AM) <\/span><\/span>smowton: but: accounts can be created for free
\n(10:09:30 AM) <\/span><\/span>smowton: so can start anew
\n(10:09:33 AM) <\/span><\/span>smowton: or, can collude
\n(10:10:38 AM) <\/span><\/span>smowton: apparently there are often very cheap listings that have \"positive feedback guaranteed\"
\n(10:11:13 AM) <\/span><\/span>smowton: Potential solutions:
\n(10:11:24 AM) <\/span><\/span>smowton: 1. Make it hard to join to begin with, e.g. must present some ID
\n(10:11:34 AM) <\/span><\/span>smowton: sucks because it's a barrier to honest people too
\n(10:11:44 AM) <\/span><\/span>smowton: 2. Use escrow, but only appropriate for expensive things
\n(10:12:24 AM) <\/span><\/span>smowton: 3. Transactions happen in person; the website just pairs you up. Problem: transfers online fraud to plain old mundane mugging
\n(10:12:36 AM) <\/span><\/span>smowton: 4. Insurance: spreads the cost
\n(10:14:09 AM) <\/span><\/span>smowton: Their solution keeps existing feedback systems but tries to bound fraud
\n(10:15:37 AM) <\/span><\/span>smowton: They build a \"risk graph\": accounts that have traded are joined by an edge weighted by dollar amount
\n(10:16:09 AM) <\/span><\/span>smowton: Turst = max-flow between buyer and seller
\n(10:16:29 AM) <\/span><\/span>smowton: presmably the hope is that fraudulent people will be walled off from honest ones by negative-feedback edges
\n(10:16:59 AM) <\/span><\/span>malte: I don't quite see how this solves the sybil attack problem
\n(10:17:09 AM) <\/span><\/span>smowton: trading with your own sockpuppets doesn't help as they're a clique
\n(10:17:15 AM) <\/span><\/span>smowton: they might as well be the same person
\n(10:17:19 AM) <\/span><\/span>malte: ah, I see
\n(10:17:23 AM) <\/span><\/span>malte: yeah
\n(10:17:37 AM) <\/span><\/span>avsm: cunning
\n(10:18:05 AM) <\/span><\/span>mrry: nice aspect of this is that, at least on eBay, you have to pay a %age fee, so there is cost to building up these edges (if you're only pretending to sell things)
\n(10:18:05 AM) <\/span><\/span>malte: unless of course you make your sockpuppets do a bunch of genuine transactions in order to link them into the honest network
\n(10:18:35 AM) <\/span><\/span>smowton: sure, so you're required to be at least X% honest
\n(10:18:41 AM) <\/span><\/span>smowton: I think this is the strong bound on fraud
\n(10:18:42 AM) <\/span><\/span>mrry: @malte, you'd still have to make large transactions with your sockpuppets, which would be expensive
\n(10:19:17 AM) <\/span><\/span>malte: mrry: yeah, point taken - you can't trade a bunch of 50c items and then defraud someone for $5000 as you don't have enough flow
\n(10:19:34 AM) <\/span><\/span>smowton: your best bet would be to genuinely be an honest trader for a few months
\n(10:19:47 AM) <\/span><\/span>smowton: then quickly make off with everyone's wallet whilst they're still in the dark
\n(10:21:42 AM) <\/span><\/span>smowton: aha, this is challenge #1
\n(10:21:58 AM) <\/span><\/span>smowton: the ability to steal a lot of cash before the users realise
\n(10:22:12 AM) <\/span><\/span>smowton: solution: your edge is suspended whilst there's an outstanding transaction
\n(10:22:22 AM) <\/span><\/span>smowton: limits the volume of trade you can perform if your reputation is low
\n(10:22:29 AM) <\/span><\/span>smowton: seems reasonable with or without bazaar
\n(10:23:46 AM) <\/span><\/span>malte: same principle as the London tube Oyster charging system :-)
\n(10:24:04 AM) <\/span><\/span>twh25: ?
\n(10:24:30 AM) <\/span><\/span>smowton: challenge #2: how to induct new users? Friends can vouch, lending their credability, or can do link-escrow (buy your initial credability, I think)
\n(10:24:41 AM) <\/span><\/span>malte: (Oyster deducts the maximum fare while you're en-route, then credits you when you touch out)
\n(10:25:32 AM) <\/span><\/span>smowton: problem: max-flow over a large graph is expensive.
\n(10:26:06 AM) <\/span><\/span>smowton: They assert real-world graphs are usually of a shape that makes this okay
\n(10:26:30 AM) <\/span><\/span>smowton: and also note we only need a vague is-it-greater-than-X answer, not the true result
\n(10:27:38 AM) <\/span><\/span>smowton: cunning technique for cheap maxflow: construct log(n) [where n is the highest weight link] graphs where graph i is restricted to edges with weight >= 2^i
\n(10:28:04 AM) <\/span><\/span>smowton: for big sellers you'll find that the sparse top-level graph says yes right away
\n(10:28:27 AM) <\/span><\/span>malte: in fact, if you assume that the majority of your sellers is honest, your performance is okay
\n(10:28:29 AM) <\/span><\/span>smowton: only need to check the lowest-level full graph if your maxflow would be very small
\n(10:28:49 AM) <\/span><\/span>smowton: Eval:
\n(10:29:18 AM) <\/span><\/span>smowton: crawled a 90-day trace of ebay (8m auctions)
\n(10:29:46 AM) <\/span><\/span>smowton: used 80% to form a risk network using observed feedback
\n(10:30:12 AM) <\/span><\/span>smowton: remaining 20% used to test
\n(10:30:36 AM) <\/span><\/span>smowton: found that total amount users could steal is always <= their previous successful transactions
\n(10:30:44 AM) <\/span><\/span>smowton: sounds like something that could be proved rather than experimented :)
\n(10:30:57 AM) <\/span><\/span>malte: yeah, surely that's a fundamental property of their system?
\n(10:31:20 AM) <\/span><\/span>smowton: <5% false positive rate
\n(10:31:36 AM) <\/span><\/span>smowton: where that means it flags an auction that actually led to positive feedback
\n(10:31:48 AM) <\/span><\/span>smowton: they blame their lack of knowledge before 90 days ago<\/p>\n

Dewdrop: An Energy-Aware Runtime for Computational RFID<\/strong><\/p>\n

(11:03:11 AM) <\/span><\/span>smowton: defn: \"computational RFID\" = computer that works solely using RF energy
\n(11:04:00 AM) <\/span><\/span>smowton: scenario: pervasive monitoring for the elderly
\n(11:04:30 AM) <\/span><\/span>malte: (or, alternatively, government surveillance and spying :-P)
\n(11:04:32 AM) <\/span><\/span>smowton: they don't like cameras for this purpose, due to privacy concerns
\n(11:04:47 AM) <\/span><\/span>smowton: motes are neat but battery powered
\n(11:06:19 AM) <\/span><\/span>smowton: so, let's use computational RFIDs, in which the reader powers the thing but it can do some on-board computation (and storage?)
\n(11:08:20 AM) <\/span><\/span>smowton: they use the Intel WISP: a CRFID prototype that can be read from 4m and has an accelerometer and temperature probe
\n(11:09:16 AM) <\/span><\/span>malte: challenges:
\n(11:09:22 AM) <\/span><\/span>malte: 1) CRFIDs have tiny energy stores
\n(11:09:30 AM) <\/span><\/span>malte: 2) programs have different energy needs
\n(11:10:28 AM) <\/span><\/span>smowton: their runtime coordinates program runs by accumulating enough energy to run it to completion before allowing it to complete
\n(11:10:58 AM) <\/span><\/span>smowton: runtime executes in a standby mode that allows us to monitor energy levels whilst still charging
\n(11:11:13 AM) <\/span><\/span>smowton: we want to avoid failure in which we run out of useful energy during a run
\n(11:12:24 AM) <\/span><\/span>malte: this is difficult because programs have different energy needs and we cannot always predict how much a particular program is going to need (e.g. because it is non-deterministic(
\n(11:13:05 AM) <\/span><\/span>malte: 3) CRFIDs have inefficiencies
\n(11:13:25 AM) <\/span><\/span>malte: e.g. overcharging might cause issues as the chip requires a fixed input voltage
\n(11:13:44 AM) <\/span><\/span>smowton: because voltage regulators throw away energy in that situatioin
\n(11:13:54 AM) <\/span><\/span>malte: 4) Energy is harvested even while executing
\n(11:15:01 AM) <\/span><\/span>malte: energy is largely harvested from EM waves in the environment, but due to frequency hopping and friends, it's often hard to predict where\/how we can harvest energy even in the near future
\n(11:15:23 AM) <\/span><\/span>smowton: gives a couple of examples of programs' performance vs. initial charge
\n(11:15:35 AM) <\/span><\/span>smowton: shows that the optimal charge differs from program to program
\n(11:15:43 AM) <\/span><\/span>malte: to make things worse, the amount of energy required to run a program may also depend on environmental features such as the distance to the reader device!
\n(11:15:45 AM) <\/span><\/span>smowton: to the point that some programs fail entirely at the optimal V for another
\n(11:16:08 AM) <\/span><\/span>smowton: extra problem: some of their examples are nondeterministic
\n(11:17:19 AM) <\/span><\/span>malte: Dewdrop is a 'clever' runtime environment that takes energy needs into account
\n(11:17:47 AM) <\/span><\/span>malte: the overall goal is to maximize execution rate (defined as the rate of successful task executions=
\n(11:17:55 AM) <\/span><\/span>smowton: just adaptively find the initial charge V per program
\n(11:18:09 AM) <\/span><\/span>smowton: continuously adapts, so if you move the reader it'll gradually converge on the new correct answer
\n(11:18:48 AM) <\/span><\/span>smowton: it looks like they assume we want to run the same program in a loop
\n(11:19:05 AM) <\/span><\/span>smowton: so waste due to failed runs is considered equivalent to wasted time due to excess charging
\n(11:20:06 AM) <\/span><\/span>smowton: implementation: exponential backoff to avoid polling sucking up all the available energy
\n(11:21:32 AM) <\/span><\/span>smowton: eval: compare task execution rate to some unspecified hardware mechanism
\n(11:22:00 AM) <\/span><\/span>smowton: manage to get higher success rate at short range and some success rate from far away when the builtin mechanism fails entirely
\n(11:24:06 AM) <\/span><\/span>smowton: Eval 2: big bag of tags, how many of them do something useful vs. output power
\n(11:24:12 AM) <\/span><\/span>smowton: again they beat the builtin mechanism<\/p>\n

SSDAlloc: Hybrid SSD\/RAM Memory Management Made Easy<\/strong><\/p>\n

(11:31:19 AM) <\/span><\/span>malte: starts off by talking about the use of memory in networked systems
\n(11:31:39 AM) <\/span><\/span>malte: (1) as cache, (2) index to reduce disk pressure
\n(11:32:52 AM) <\/span><\/span>malte: they identify a problem in the fact that cost of DRAM in a commodity server scales linearly up to 64 GB, but super-linearly beyond
\n(11:33:05 AM) <\/span><\/span>malte: second problem: disk speed is not increasing (seek etc.)
\n(11:33:27 AM) <\/span><\/span>malte: usually tackled by using high speed disk arrays, but they are expensive
\n(11:33:56 AM) <\/span><\/span>malte: their proposal to address the problems: use flash as memory
\n(11:34:55 AM) <\/span><\/span>malte: first problem is addressed by scaling beyond the 64 GB limit by adding flash memory
\n(11:34:55 AM) <\/span><\/span>malte: doing this would reduce the TCO and lead to more efficient server utilization
\n(11:35:42 AM) <\/span><\/span>malte: with flash, random reads are very fast, but writes are slow
\n(11:36:32 AM) <\/span><\/span>malte: so this solves problem number 2
\n(11:36:50 AM) <\/span><\/span>malte: now the question is how to integrate flash into the well-known memory hierarchy
\n(11:37:08 AM) <\/span><\/span>malte: initially, SSDs were put into the same category as disks because they are non-volatile
\n(11:37:26 AM) <\/span><\/span>malte: they don't believe this and argue that SSDs should be used and addressed like memory
\n(11:37:49 AM) <\/span><\/span>malte: existing approaches: use SSD as swap or via mmap
\n(11:37:59 AM) <\/span><\/span>malte: + applications don't need to be modified
\n(11:38:09 AM) <\/span><\/span>malte: - native pager only delivers 10% of SSF performance
\n(11:38:21 AM) <\/span><\/span>malte: - even a flash-aware pager only gets up to 30%
\n(11:38:37 AM) <\/span><\/span>malte: they assert that this is because OS pagers weren't designed for flash memory
\n(11:40:20 AM) <\/span><\/span>malte: the concrete issue appears to be in the fact that a page on the SSD is first brought into memory, so we have to read $pagesize worth of data, instead of just the object we're interested in
\n(11:40:38 AM) <\/span><\/span>smowton: I wonder how similar this is to XIP stuff
\n(11:40:55 AM) <\/span><\/span>smowton: which afaik allows you to execute stuff off disk without pulling pages into ram
\n(11:41:00 AM) <\/span><\/span>smowton: not sure how they implemented that
\n(11:41:26 AM) <\/span><\/span>malte: they suggest non-transparent tiering, which requires applications to be modified so they are flash-aware
\n(11:41:26 AM) <\/span><\/span>smowton: prsumably it would require an interface for fine-grained disk use whilst mimicing memory however
\n(11:42:50 AM) <\/span><\/span>malte: but this is tedious because it requires a lot of knowledge about flash memory and more verbose code due to bookkeeping code for the flash object store
\n(11:43:03 AM) <\/span><\/span>malte: instead, their goal is to run 'mostly' unmodified apps
\n <\/span>(11:43:40 AM) <\/span><\/span>malte: they want to use DRAM more efficiently and not cache at page granularity but below that
\n(11:43:57 AM) <\/span><\/span>malte: plus they want to use the SSD well and limit the number of writes
\n(11:44:05 AM) <\/span><\/span>malte: (which is fairly standard stuff)
\n(11:44:26 AM) <\/span><\/span>smowton: they want to use it as a a log-structured object store
\n(11:44:35 AM) <\/span><\/span>smowton: which is interesting as afaik some drives do that in firmware already
\n(11:44:41 AM) <\/span><\/span>smowton: and\/or you should use JFFS2 :)
\n(11:45:52 AM) <\/span><\/span>malte: they establish a 1 page = 1 object correspondence
\n(11:46:04 AM) <\/span><\/span>malte: now this obviously may waste huge amounts of memory
\n(11:46:22 AM) <\/span><\/span>malte: so they have a compacted cache in RAM
\n(11:46:56 AM) <\/span><\/span>malte: (as well as a page buffer, where the pages are expanded from the compact representation)
\n(11:49:43 AM) <\/span><\/span>malte: they implemented the on-demand paging (generation of sparse pages from compact representation) using mprotect
\n(11:50:29 AM) <\/span><\/span>malte: on the lowest level, there is a log-structured object store on the SSD
\n(11:50:47 AM) <\/span><\/span>malte: to which things from the in-RAM compact cache are written out
\n(11:52:09 AM) <\/span><\/span>malte: on the SSD, they use a copy-and-compact garbage collector to write live and dirty objects and remove everything no longer required ('freed' objects and objects written elsewhere)
\n(11:53:22 AM) <\/span><\/span>malte: in addition to the OPP model (one object per page), they also support a MP model, which is more like traditional paging
\n(11:53:40 AM) <\/span><\/span>malte: their entire implementation is ~11k lines of C++
\n(11:54:11 AM) <\/span><\/span>malte: they give some numbers for the overhead of SSDAlloc's runtime intervention
\n(11:54:28 AM) <\/span><\/span>malte: they are all sub-microsecond
\n(11:54:37 AM) <\/span><\/span>malte: the combined overhead is 0.83 \u00c2\u00b5sec
\n(11:56:17 AM) <\/span><\/span>malte: for a bunch of benchmarks, they get performance improvements between ~5x and ~17x over using SSD as swap
\n(11:56:23 AM) <\/span><\/span>malte: (for SSDAlloc-OPP)
\n(11:56:35 AM) <\/span><\/span>malte: the advantage for SSDAlloc-MP is less pronounced (1.5x to 3x)
\n(11:59:08 AM) <\/span><\/span>malte: for a macrobenchmark (memcached), they see a large benefit in using SSDAlloc-OPP for small requests
\n(12:00:12 PM) <\/span><\/span>malte: as the request size increases, the advantage diminishes and ultimately all approaches are the same
\n(12:01:15 PM) <\/span><\/span>malte: they claim their approach delivers 90% of raw SSD performance, compared to max. 30% for other approaches<\/p>\n

SliceTime<\/em>: A Platform for Scalable and Accurate Network Emulation<\/strong><\/p>\n

(2:25:51 PM) <\/span><\/span>smowton: SliceTime: A Platform for Scalable and Accurate Network Emulation
\n(2:27:39 PM) <\/span><\/span>smowton: Testbeds are expensive, and simulations lack fidelity
\n(2:27:46 PM) <\/span><\/span>smowton: so, let's hybridise the two
\n(2:28:53 PM) <\/span><\/span>smowton: Connect real nodes using a realtime simulation that can also insert virtual nodes
\n(2:30:31 PM) <\/span><\/span>smowton: Simulations are often not capable of operation in real-time
\n(2:31:00 PM) <\/span><\/span>smowton: and thus we can easily break this hybrid world because their perception of time drifts apart
\n(2:32:03 PM) <\/span><\/span>smowton: They fix this by slowing down the real nodes
\n(2:33:02 PM) <\/span><\/span>smowton: Want to operate on real nodes
\n(2:35:31 PM) <\/span><\/span>smowton: They run the \"real\" nodes inside VMs
\n(2:35:43 PM) <\/span><\/span>smowton: and barrier if they run ahead of simulation time (or vice versa
\n(2:37:28 PM) <\/span><\/span>smowton: Implement using Xen
\n(2:38:39 PM) <\/span><\/span>smowton: Xen has means to tell the difference between virtual and \"wall\" time; presumably these are appropriately mangled
\n(2:40:20 PM) <\/span><\/span>smowton: yup indeed they are
\n(2:41:37 PM) <\/span><\/span>smowton: Wrote an 802.11 equivalent of tun to allow them to inject virtual wireless packets into real nodes
\n(2:44:30 PM) <\/span><\/span>smowton: eval shows it's fairly accurate at making machines think links are the way the simulator says they are
\n(2:44:55 PM) <\/span><\/span>smowton: found that barrier density and so accuracy functions as you'd expect too
\n(2:46:16 PM) <\/span><\/span>smowton: Overhead is pretty severe at 1ms accuracy, but much better if you'll settle for coarse grains
\n(2:47:04 PM) <\/span><\/span>smowton: eval 2: is it useful? Duplicated an experiment called AODV, which had some people conduct real-life random walks with laptops and observe when they were able to communicate
\n(2:47:34 PM) <\/span><\/span>smowton: took the GPS traces from that experiment and made a model of the world they were occupying
\n(2:47:58 PM) <\/span><\/span>smowton: found that the simulated world gave a very similar result to the real one<\/p>\n

Accurate, Low-Energy Trajectory Mapping for Mobile Devices<\/strong><\/p>\n

(3:32:49 PM) <\/span><\/span>smowton: Better version of MapMyRide etc
\n(3:34:29 PM) <\/span><\/span>smowton: GPS is troublesome because it's rather energy intensive
\n(3:36:20 PM) <\/span><\/span>smowton: idea: use GPS infrequently to pin your location down, then use less precise methods like WiFi or 3G localisation more frequently
\n(3:37:33 PM) <\/span><\/span>smowton: 3G is especially nice because you have to idly watch the signal anyway to decide when to roam and listen for push notifications
\n(3:38:50 PM) <\/span><\/span>smowton: They also use a compass and accelerometer at low power to decide when to use their different localisation techniques
\n(3:43:04 PM) <\/span><\/span>smowton: 3G is also super tricky in urban areas because your perceived location will often veer wildly around the place in response to radio propagation
\n(3:45:03 PM) <\/span><\/span>smowton: They find that smoothing over time actually helps a lot
\n(3:45:08 PM) <\/span><\/span>smowton: as does snapping to roads
\n(3:45:15 PM) <\/span><\/span>smowton: but only *after* the smoothing
\n(3:47:27 PM) <\/span><\/span>smowton: They use an HMM to make the naive point sequence sane, using knowledge both of what one is likely to see in a given grid, and the probability of moving from one grid to another
\n(3:49:33 PM) <\/span><\/span>smowton: They're actually pretty tolerant of wild leaps about the grid, as they need it to deal with black spots in coverage
\n(3:51:52 PM) <\/span><\/span>smowton: The later snap-to-roads stage doesn't tolerate leaps because they want a conceivable track at the end of the day
\n(3:54:30 PM) <\/span><\/span>smowton: Eval: compared against GSM radio analysis + snap-to-roads and to GPS every 4 mins + snap-to-roads
\n(3:55:09 PM) <\/span><\/span>smowton: They characterise sub-sections of the trace as \"right\" or \"wrong\" and find that they're right 2.4x as often as the best of their rivals
\n(3:55:34 PM) <\/span><\/span>smowton: Find that the grid-mapping stage is very important
\n(3:56:01 PM) <\/span><\/span>smowton: hints from sensors only give them an extra 5%, but apparently help a lot in certain restricted situations<\/p>\n

Improving Wireless Network Performance Using Sensor Hints<\/strong><\/p>\n

(4:05:06 PM) <\/span><\/span>smowton: Observation: people's mobility is often characterised by static periods and mobile periods
\n(4:05:20 PM) <\/span><\/span>smowton: WLAN et al are basically set up for static operation and do badly when moving
\n(4:06:36 PM) <\/span><\/span>smowton: The right way to work differs (ignore short-term variations or not?)
\n(4:06:44 PM) <\/span><\/span>smowton: So it'd be nice to figure out when we're moving and when we're not
\n(4:10:03 PM) <\/span><\/span>smowton: They can also use other physical hints, e.g. direction, speed
\n(4:12:29 PM) <\/span><\/span>smowton: Application 1: rate adaptation in WLAN.
\n(4:12:48 PM) <\/span><\/span>smowton: Took some physical connectivity traces and simulated TCP operating over the simulated links
\n(4:13:02 PM) <\/span><\/span>smowton: found only got 35-60% of best possible using standard ways to rate adapt
\n(4:13:55 PM) <\/span><\/span>smowton: In mobile situations there are lots of burst drops
\n(4:14:15 PM) <\/span><\/span>smowton: In static situations they're mostly random losses
\n(4:15:36 PM) <\/span><\/span>smowton: Invented a new way to rate-adapt if you're moving: reduce rate on loss; keep a 10ms history and don't try any bitrate that failed in that history
\n(4:16:40 PM) <\/span><\/span>smowton: Simulated again: found 10-25% better TCP throughput using their method
\n(4:16:59 PM) <\/span><\/span>smowton: compared to some existing protocols: SampleRate, RRAA, RBAR, CHARM
\n(4:17:13 PM) <\/span><\/span>smowton: Worse when static by up to 28% due to pessimism
\n(4:17:27 PM) <\/span><\/span>smowton: so: as we said at the start, it'd be good to figure out when we're moving and switch modes
\n(4:18:39 PM) <\/span><\/span>smowton: real-world eval:
\n(4:18:52 PM) <\/span><\/span>smowton: 2 environments, 10 movement patterns
\n(4:20:30 PM) <\/span><\/span>smowton: did 17-28% better than existing schemes when hint-aware
\n(4:20:41 PM) <\/span><\/span>smowton: i.e. switching their scheme on and off as appropriate to movement
\n(4:21:24 PM) <\/span><\/span>smowton: They concede that PHY layer techniques are better, e.g. SoftRate
\n(4:21:35 PM) <\/span><\/span>smowton: but they require h\/w modifications
\n(4:21:43 PM) <\/span><\/span>smowton: they got 90% of softrate however
\n(4:22:26 PM) <\/span><\/span>smowton: they claim that a two-mode setup is better than a continuous sliding scale between static and mobile operations
\n(4:22:47 PM) <\/span><\/span>smowton: evidence using moving traces at various speeds: *any* movement yields highly correlated losses; none yields no correlation
\n(4:23:15 PM) <\/span><\/span>smowton: Example 2: picking an AP
\n(4:24:56 PM) <\/span><\/span>smowton: Scan more often when moving
\n(4:25:55 PM) <\/span><\/span>smowton: also wrote a fairly cunning thing that learns where the APs are and uses a heading hint to figure out when it can minimise handoffs by ignoring a tempting AP in favour of one it thinks will shortly come into range
\n(4:26:52 PM) <\/span><\/span>smowton: Example 3: using speed to optimise vehicle mesh nets
\n(4:27:11 PM) <\/span><\/span>smowton: estimate connection time proportional to 1\/speecd
\n(4:27:30 PM) <\/span><\/span>smowton: found it helps when planning how much to send to a vehicle you see<\/p>\n","protected":false},"excerpt":{"rendered":"

Hey all, Today’s LiveBlog is even liver: Join us on IRC at chat.freenode.net, channel #nsdi11 (go here for web IRC access).<\/p>\n","protected":false},"author":17,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[6,23,1],"tags":[],"_links":{"self":[{"href":"https:\/\/www.syslog.cl.cam.ac.uk\/wp-json\/wp\/v2\/posts\/120"}],"collection":[{"href":"https:\/\/www.syslog.cl.cam.ac.uk\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.syslog.cl.cam.ac.uk\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.syslog.cl.cam.ac.uk\/wp-json\/wp\/v2\/users\/17"}],"replies":[{"embeddable":true,"href":"https:\/\/www.syslog.cl.cam.ac.uk\/wp-json\/wp\/v2\/comments?post=120"}],"version-history":[{"count":13,"href":"https:\/\/www.syslog.cl.cam.ac.uk\/wp-json\/wp\/v2\/posts\/120\/revisions"}],"predecessor-version":[{"id":134,"href":"https:\/\/www.syslog.cl.cam.ac.uk\/wp-json\/wp\/v2\/posts\/120\/revisions\/134"}],"wp:attachment":[{"href":"https:\/\/www.syslog.cl.cam.ac.uk\/wp-json\/wp\/v2\/media?parent=120"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.syslog.cl.cam.ac.uk\/wp-json\/wp\/v2\/categories?post=120"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.syslog.cl.cam.ac.uk\/wp-json\/wp\/v2\/tags?post=120"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}