The Lagniappe Programming Environment

Several directions are moving forward on the Lagniappe front.

Byzantine-fault tolerance is still our big target application. We have learned many interesting things about BFT, and how it differs from the traditional network applications we originally looked at.

We are currently in the process of writing BFT in Lagniappe, and in the next few weeks we should start to have the beginnings of the application take shape.

One interesting thing that Lagniappe allows us to do is look at BFT in terms of layered development and testing. The highly modular structure of Lagniappe makes this much easier. The small WiP presentation that I gave at OSDI talks about automatically applying fault-tolerance protocols to Lagniappe applications, and this layered breakdown of BFT is starting to clear up the details of how to make such automatic fault tolerance happen.

Stay tuned as we have exciting things that should be exiting the pipeline in the next few months!

Labels: automatic fault tolerance, BFT, OSDI

I've uploaded the WiP slides from OSDI.

The picture here has also been updated to properly reflect the structure of the lagniappe compiler in terms of the high-level transformations that occur to the models as we do our source to source translation.

There have been some updates in the code repository as we've added a replicated, ordered queue application (one of the components of a BFT RSM).

Thanks!

Labels: BFT, OSDI

I have my two initial benchmark applications coded up. They still need some testing, and I still need to finalize the workload generation, but having the apps down on the machine is nice.

I haven't touched the multi-machine code in a week. It just got to me after a while. The serialization aspect was killing me. I've decided to use the boost serialization library. At first I didn't think there was that much that I needed serialization for, but I eventually figured out that was not definitely not the case. Using the boost library will allow me to keep drastic changes between the trunk development of Lagniappe and the multi-machine branch, which will hopefully mean that the multi-machine support will be easier to merge back in when it's all said and done.

Labels: benchmarks, multi-machine

While the OSDI deadline has come and gone, I am now making the final push towards defending and turning in my dissertation by the middle of August. Needless to say, this is the most important deadline I've ever run up against and it's not okay to pull the paper for this one.

I am working on two major tasks regarding the main system. The first is making Lagniappe function on multiple machines at the same time. If Lagniappe runs on multiple machines, the true heterogeneity of multi-* becomes an issue (as now we have a drastically different communication channel in the mix). The second task is combining operators based on their state preferences. I feel that we can truly answer the pipelined vs. parallel question based on the state access semantics of the operators in an application.

The third major issue is creating a suite of benchmark applications. The benchmarks has been a thorn in my side for a while, but I am confident we can make it all come together.

Labels: dissertation, multi-machine, operator combination

Post OSDI I'll update the site on all of the new stuff that has been built into Lagniappe in the last month. It's really coming together, but there is still so much to do before the deadline.

Labels: OSDI