January 23, 2018
January 23, 2018
January 16, 2018
Spectre is a shock, and the architectural implications seem unbounded. The weirdest part is that it’s not clear what the next generation of CPUs should do in response. Here are a few possibilities, but there are no easy answers.
December 4, 2017
For a recent project, my group couldn’t find reusable, open-source tools for understanding the hardware costs of deep neural network accelerators. We’ve published a simple first-order model for the latency and energy of CNN execution.
October 14, 2017
I’m giving a talk at the NOPE workshop about impossible problems in approximate computing. Here are some research directions that are no longer worth pursuing—and a few that are.
November 23, 2016
You can get CS papers published with shoddy statistics, but that doesn’t mean you should. Here are three easy ways to bungle the data analysis in your evaluation section: don’t even try to use statistics when you really ought to; misinterpret an inconclusive statistical test as concluding a negative; or run too many tests without considering that some of them might be lying to you. I’ve seen all three of these mistakes in multiple published papers—don’t let this be you!
June 15, 2016
Say you have a program that’s right only some of the time. How can you tell whether it’s correct enough? Using with some Wikipedia-level statistics, it’s pretty easy to make probabilistic statements about quality. I’ll explain two strategies for measuring statistical correctness. Then I’ll argue that it’s deceptively difficult produce guarantees that are any stronger than the ones you get from the basic techniques.
May 2, 2016
The mainstream real-time graphics APIs, OpenGL and Direct3D, make miserable standard bearers for the age of hardware heterogeneity. Their approach to heterogeneous programming leads to stringly typed interfaces, a huge volume of boilerplate, and impoverished GPU-specific programming languages.
April 17, 2016
November 25, 2015
No interest in computer science? Already have an advanced degree? These puppies don’t care! Be careful before you click; you’ll be preparing your application materials before you get to #4.
September 26, 2015
September 8, 2015
Apple is on track to diverge from ARM and x86 to design its own proprietary instruction set. This good for the future of hardware–software co-design.
August 3, 2015
LLVM is a godsend of a research tool. Here are some detailed notes on what LLVM is, why you would want to use it for research, and how to get started as a compiler hacker.
January 25, 2015
IEEE Micro Top Picks is an annual special issue that collects the best of each year’s computer architecture conferences. This year, the chairs experimented with a community input process, which meant that even a lowly grad student could read the submissions and contribute comments. Here are my favorite papers from the year.
January 12, 2015
I did some iOS programming recently (for an unknown reason). Using the new Swift language has made it evident the language is young—and, like a rebellious teenager, it conflicts with its much older framework counterpart, Cocoa. Here are two places where the disconnect is most stark, and where Swift should grow more sophisticated type-system features.
December 2, 2014
I’m on a continuing quixotic quest to improve computer science publishing. Here’s my top-secret plan for launching a new publication venue that necessarily starts from zero credibility. It’s a two-pronged evil plan: first, incentivize good reviews, and second, address an underserved market.
November 25, 2014
Architects tend to conflate FPGAs too closely with ASIC acceleration. This is a mistake: when viewed as an acceleration substrate, FPGAs are a unfortunate accident of history with an exceptionally bad programming model. We should pay more attention to better alternatives.
November 6, 2014
My C and C++ type annotation project, Quala, aims to enable type-aware compiler research. This post demonstrates a type system that can insert dynamic null-pointer dereference checks to stop segfaults before they happen.
October 19, 2014
The world has no shortage of frustratingly unhelpful bug reports, but it can be hard to explain what makes them bad—and how they can improve. Try scoring your next report on this handy five-point scale.
October 7, 2014
Computer science conferences have shortcomings that many of us in the community are motivated to solve. One alternative to reforming conferences incrementally is to start alternative venues. New, lightweight, open-access journals could provide a proving ground for publishing-model ideas. It’s a risky prospect, but it’s a risk worth taking.
September 27, 2014
August 17, 2014
Novel type systems can help catch lots of bugs and realize other wonders of programming magic. But they can be a pain to add to an industrial-strength compiler. Quala is a new open-source project to add pluggable type checkers to Clang in the hopes of making custom type systems as easy to opt into as LLVM passes.
June 23, 2014
June 7, 2014
June 1, 2014
Why does baking something into the hardware make it faster? It may seem obvious, but I think there are four distinct reasons for implementing something in hardware. It’s cruicial to remember that they are separate advantages: architectures can “win” in some categories without addressing them all.
May 25, 2014
Conference and journal publishers want PDFs with fonts embedded. The Web is full of bad, incomplete, and broken advice about how to embed fonts. Here’s a tiny script that does it right.
May 11, 2014
Working with undergraduate researchers can be totally awesome. Here’s some advice on making undergrad research work for everyone.
April 27, 2014
If you use git, you might occasionally need to do things. This post explains how to do things with git.
April 20, 2014
April 14, 2014
I made a video of a short talk I gave at a workshop recently. The talk is a call to research action: the approximate-computing community should be thinking more carefully about the problem of specifying quality—even when programmers don’t know what quality means.
March 7, 2014
I helped run WACAS 2014, a workshop on approximate computing, this week. Here are a few notes on broad topics that came up at the workshop.
February 23, 2014
I updated this site’s design so that it sucks a little bit less. Within: some ideas and techniques you can steal.
February 21, 2014
As a grad student, it’s a great idea to build a personal academic Web site. There are many tools that can help you build a good one. I’ve tried many of them and I think you should use Jekyll.
February 9, 2014
When reading and writing papers on approximate computing, I often find myself comparing proposed systems to an imaginary ideal. Even though that ideal is clearly unrealizable, it is helpful to conceptualize it and measure the ways that real systems fall short in comparison.
February 2, 2014
There are lots of reasons to release code as an academic. Be careful to think about which ones apply to your code release—and communicate them with the world.
January 26, 2014
Some papers on approximate computing systems propose simple systems for checking computations’ error rates. These systems can be naive and ineffective at solving the problems they were meant to address.
January 19, 2014
Vega is a new plotting system that I’m totally in love with. There are a few challenges involved in abusing it as a system for producing publication-quality figures. I describe some of the problems and some workarounds for them.
January 12, 2014
In which I totally freak myself out by counting all the coffee I drank during my deadline-laden autumn quarter.
December 30, 2013
April 20, 2013
Lots of research projects need to instrument code while it gets compiled. While LLVM passes are a convenient way to implement instrumentation, the official LLVM documentation doesn’t make it clear how to use them that way easily. Here’s a trick that lets you instrument programs when compiling them with the Clang command-line compiler driver.
February 10, 2013
Some notes on one possible direction for addressing efficiency and correctness issues with parallelism in interpreters for dynamic (scripting) languages. I propose that the problem be addressed at the language level via a dynamic enforcement of locking discipline. This approach has the ancillary benefit of discouraging programmers from ignoring potential concurrency bugs.
January 24, 2013
Do you ever want to analyze a dynamic execution of a program compiled to LLVM bitcode but want to skip the headaches involved in bitcode instrumenation? Yeah, me too. In cases where the performance doesn’t matter, using an interpreter can be a good option for examining an execution. I built a small, hacky library you can use to quickly prototype your analyses using LLVM’s built-in interpreter.
January 5, 2013
I worked on a project recently that showed that neural networks can act as accelerators for “soft” programs—even when they have nothing to do with learning, classification, or other tasks that make up the traditional domain of neural networks. We found that a simple accelerator based on a hardware neural network implementation can make some programs run much more efficiently.
October 25, 2012
Web browsers on mobile devices are slow and use too much energy. WebChar is a system for automatically generating hypotheses about what exactly makes some pages slower and more energy-intensive than others. WebChar uses real-world measurements together with machine learning to create a model of browser resource consumption and mines it to generate new hypotheses. We found some surprising pitfalls in an analysis of browsers on two mobile systems.
October 25, 2012
The team behind PyPy, an astoundingly successful Python JIT, has been working on improving the performance of multithreaded Python programs. The tactic so far has been to adhere closely to the semantics of CPython’s global interpreter lock, or GIL, while mitigating its performance impact. But GIL semantics are expensive to enforce and encourge Python programmers to write subtly incorrect parallel programs. High-performance Python implementations should abandon not just the GIL but also its model for parallel programming.
September 9, 2012
I’ve written a simple Python library for running massively parallel tasks on compute clusters. Cluster-Workers makes it simple to get up and running with the kinds of parallelism that academics usually need when running large-scale batches of experiments. See if it fits your cluster-y use case as well as it does mine.
August 5, 2012
Some recent press points out how important energy efficiency has been to making computers ubiquitous over the last few decades. But they miss the ominous signs that this trend is in the process of falling off a cliff.
April 24, 2012
A couple months ago, a story made the nerd-press rounds about Apple’s trademark application and several patents for something called a “macroscalar” processor architecture. I’ve taken a stab at decoding the publicly available information about macroscalar architectures to give a coherent picture of the idea.
April 17, 2012
Janet Tu writes in the Seattle Times today about a new Greenpeace report analyzing the use of renewable energy in data centers (or, as they put it, “the cloud”). I provided a couple of comments for the Times story and I’ll expand a little bit here on the importance and feasibility of improving energy efficiency in a cloud-centric world.
March 19, 2012
February 12, 2012
December 9, 2011
For a recent research project, I measured the power consumption of a smartphone. I am clueless when it comes to electronics and I didn’t want to drop a lot of (my advisor’s) cash, so I needed a simple, relatively cheap setup to get reasonable power measurements. This post describes how you can get a similar apparatus up and running with a custom Python library I wrote for controlling a DC power supply.
July 7, 2011
As a side project, I wrote a simple implementation of green threads for
the Python programming language. The library is called Bluelet
and it uses Python’s native implementation of coroutines. Bluelet makes it
easy to write concurrent socket programs without OS threads, multiple
June 11, 2011
June 8, 2011
For my CSE 503 class project, I implemented a detailed quality-of-service profiler, a tool to help identify code that is inessential for output correctness. The tool is an extension to work at MIT that originally proposed a quality-of-service profiler; this project is a slightly different take on the same basic idea.
March 25, 2011
If you’re like me, you’re probably not very interested in the latest deadline extension for the First Annual Multiconference on Informatics and Cybernetics. Here’s a filter for Gmail that catches most of this kind of conference spam.
February 5, 2011
My paper on EnerJ, a language extension for approximate computing, will be presented at PLDI 2011! This is especially exciting because I hope EnerJ will be the basis for a bunch of new research directions in the near future. This is a summary of EnerJ’s type-based approach to bringing safety to unsafe, unreliable hardware.
January 22, 2011
My recent research has focused on power efficiency gains available by compromising on strict correctness guarantees. That is, many applications (like audio or video processors) can tolerate occasional errors in their execution—and permitting some errors can yield large gains in power or performance. Many researchers have come to a similar realization independently, so here I’ll try to collect together a few different approaches to the issue.
January 21, 2011
I started an academic blog! Come back often.