dtrace.conf(12) wrap-up

For the second time in as many quadrennial dtrace.confs, I was impressed at how well the unconference format worked out. Sharing coffee with the DTrace community, it was great to see some of the oldest friends of DTrace — Jarod Jenson, Stephen O’Grady, Jonathan Adams to name a few — and to put faces to names — Scott Fritchie, Dustin Sallings, Blake Irvin, etc — of the many new additions to the DTrace community. You can see all the slides and videos; these are my thoughts and notes on the day.

Bryan provided a typically eloquent review of the state of the community. DTrace development is alive and well — after a lull while Oracle’s acquisition of Sun settled in — with new support for a variety of languages and runtimes, and new products that rely heavily on DTrace as a secret sauce. Bryan laid out some important development goals, areas where many have started straying from the edges of the completed DTrace features into the partially complete or starkly missing. We all then set to work hammering out a loose schedule for the day; I’ll admit that at first I was worried that we’d have too many listeners and not enough presenters, but the schedule quickly filled — and with more topics than we’d end up having time to cover.

User-land CTF and Dynamic Translators

DTrace, from its inception, has been a systemic analysis tool, but the earliest development focused on kernel observability — not a surprise since Bryan, Mike, and I developed it while working in the Solaris kernel development. After its use spread (quickly) beyond the kernel team, use shifted more and more to features focused on understanding C and C++ applications in user-land, and then to applications written in a variety of higher-level languages — Java, Ruby, Perl, Javascript, Erlang, etc. User-land Statically Defined Tracing (USDT) is the DTrace facility that enables rich tracing of higher-level languages. It was a relatively late addition to DTrace (integrated in 2004, well after the initial integration in 2003), and since then we’ve learned a lot about what we got right, what we got wrong, and where it’s rough — in some cases very rough — around the edges.

In his opening remarks, Bryan identified USDT improvements as a key area for the community’s focus. In DTrace development we tried to focus on making the impossible possible rather than making the possible easier. In its current form, some things are still impossible with DTrace, namely consumption of type structures from user-land programs; stable, non-privileged use of DTrace; and support for different runtime versions. Dave Pacheco and I took the first  slot on the schedule and spoke (at length — sorry) about solutions to these problems.

While others had the benefit of a bit more time to prepare, I did have the advantage of spending many years idly contemplating the problem space and possible solutions. On the subject of user-land type information (in the form of CTF), I identified the key parts of the code that would would need some work. For the USDT enhancements, we discussed dynamic translators — D code that would be linked and executed at runtime, contrasted with today’s static translators that are compiled into a D program — how they would address the problem, and how these ideas could be extended to the kernel (for once, user-land is actually a bit ahead).

I’ll go into the details of our off the cuff proposals, and delve into the code to firm up those ideas in a future blog post. Beyond the extensive implementation work we laid out, the next step is to gather the most complicated, extant USDT providers and proposals for other providers, and figure out what they should look like in the new, dynamic translator world.

The D Language

Next up, my long-time colleague, DTrace contributor, Eric Schrock led the discussion on D language additions. The format of a D program is heavily tied to DTrace’s implementation: all clauses must trace a fixed amount of data, and infinite loops are forbidden. For this reason, D lacks the backward branches needed for traditional looping, subroutines for common code, and if/else clauses for control flow. Each of these has a work-alike — unrolled loops, macros, and predicates or the ternary operator — but their absence renders D confusing to some — especially those unaware of the motivation. Further, the D language need not necessarily hold the underlying implementation so central.

Eric discussed some proposals for how each might be addressed, and I noted that it would be possible to create a prototype environment where we could try out these “D++” features by compiling into D work-alikes. The next step is to identify the most complicated D scripts, and see what they might look like for various incarnations of those language features.

Work with DTrace

The next few sessions focused not on changes to DTrace, but interesting work done using DTrace:

John Thompson of Sony talked about their port of DTrace to the Playstation Vita (!). Sony developers are given access to DTrace, but found it to be unfamiliar and unapproachable. John spoke his attempts to remedy this by replacing D with a C++-like interface which he implemented by replacing the D compiler with Clang.

My Fishworks colleague, Brendan Gregg, showed some of beautiful visualizations they’ve been developing at Joyent, and talked about the analyses those visualizations enabled. As always, it was fascinating stuff. If you don’t read Brendan’s blog, you really should. Long-time DTrace advocate, Theo Schlossnagle, talked about the visualizations they’re doing in Circonus — also fascinating stuff for anyone thinking about how to present system activity in comprehensible ways. Richard Elling showed the DTrace-based visualizations Nexenta used at VMworld to rave reviews.

Mark Cavage presented Joyent’s work bringing DTrace to node.js; Scott Fritchie talked about DTrace for Erlang. Both were useful sources of ideas for how we could improve USDT.

Ryan Stone presented the state of DTrace on FreeBSD. That DTrace is not enabled in the build by default remains a key obstacle for adoption. I hope that Ryan et al. are able to persuade the FreeBSD leadership that their licensing fears are misguided.

DTrace for OEL

I was delighted that Kris van Hees was able to attend to present the Oracle port to Linux. DTrace for OEL was announced at Oracle Open World 2011, but the initial beta didn’t live up to its billing at OOW. As is often the case, this was more a failure of messaging than of engineering. Kris and his team are making steady progress. While it’s not yet in the public beta, they have the kernel function boundary tracing provider (fbt) implemented. Most heartening of all, Oracle intends to keep DTrace for OEL moving forward as the community evolves and improves DTrace — rather than forking it. How that plays out, and what that means for DTrace on Oracle Solaris will be interesting to see, but it’s great to hear that Kris sees the value of DTrace ubiquity and DTrace compatibility.

As was remarked several times, having DTrace available on the fastest growing deployment platform will be the single most significant accelerator for DTrace adoption. The work Kris and his team at Oracle are doing is probably the most important in the DTrace ecosystem, and I think that I speak for the entire DTrace community in offering to assist in any way possible.

A ZFS DTrace Provider

Matt Ahrens and George Wilson — respectively the co-inventor of ZFS, and the preeminent SPA developer — presented a proposal for a DTrace provider for ZFS. ZFS is a highly sophisticated filesystem, but one that is also difficult to understand. Building in rich instrumentation is going to be a tremendous step forward for anyone using ZFS (for example, our mutual employer, Delphix).

Whither DTrace?

Jarod Jenson — the first DTrace user outside of Sun — took the stage in the final session to talk about DTrace adoption. Jarod has made DTrace a significant part of his business for many years. What continues to amazing him, despite numerous presentations, demonstrations, and lessons, is the relatively low level of DTrace adoption. DTrace is a tool that comes alive in the hands of a skilled, scientific, incisive practitioner — and in all of those, Jarod is superlative — but it can have a high bar of entry. There were many concrete suggestions for how to improve DTrace adoption. Most of them didn’t hold water for me — different avenue for education, further documentation, community outreach, higher level tools, visualizations, etc. — but two were quite compelling: DTrace for Linux, and DTrace on stackoverflow.com (and the like). I don’t know how much room there is to participate in the former, but by all means if there are DTrace one-liners that solve problems (on Mac OS X for example), post them, and get people covertly using DTrace.

The core DTrace community is growing. It was great to see old friends like Steve Peters who worked on porting DTrace to Mac OS X in the same room as Kris van Hees as he spoke about his port to Linux. It was inspiring to see so many new members of the community, eager to use, build and improve DTrace. And personally it inspired me to get back into the code to finish up some projects I had in flight, and to chart out the course for some of the projects we discussed.

Thanks to everyone who attended dtrace.conf in person or online. And thanks especially to Deirdre Straughan who made it happen.

Posted on April 9, 2012 at 6:03 pm by ahl · Permalink
In: DTrace · Tagged with: , , , , , , , ,

5 Responses

Subscribe to comments via RSS

  1. Written by UX-admin
    on April 10, 2012 at 1:57 pm
    Permalink

    “…is the relatively low level of DTrace adoption”

    I remember when I took my DTrace courses: it took nothing short of a kernel engineer to be able to leverage the power of DTrace. Back then I was just starting to get my feet wet with kernel-level structures in Solaris, and I distinctly remember that my every second question was

    “–WAIT! Where did THAT structure come from now!?! How did you know to access that?!?”

    And the answer was always the same: “you have to be familiar with the internal kernel structures.”

    Unfortunately, the contemporary system administrator, who is ironically the prime beneficiary of the power DTrace offers, is very far removed from any kind of C programming and kernel engineering. That is why DTrace never saw wider adoption outside of kernel engineering circles.

    • Written by ahl
      on April 10, 2012 at 4:25 pm
      Permalink

      You’re right. As I use DTrace, I spend a lot of my time browsing kernel source code, picking through /usr/lib/dtrace, looking at old blog posts, and reviewing the docs. The dtrace(1M) command itself could do more to be helpful.

    • Written by Brendan Gregg
      on April 12, 2012 at 5:25 am
      Permalink

      I wouldn’t confuse DTrace with the original DTrace course taught by Sun. It was written for kernel engineers, not system administrators.

      I’ve taught that course, and I also flew to the US during its development and met the author. It was the first course he wrote, and he did a pretty good job, but — he wrote it as an internal 2 day crash course for kernel engineers. Sun decided to reuse it as the customer course, without changing the content. I attended a trial run and was pretty shocked – one of my recommendations was to make it either 4 or 5 days, to have a chance for the instructor to ad-lib all the assumed knowledge.

      Years later, Sun/Oracle have now split it into two courses: one for developers and one for sysadmins, which makes much more sense. If I were teaching the sysadmin course, I would structure it to avoid such a need for kernel structure familiarity.

      I hope the years this was taught as a kernel engineering course hasn’t hurt adoption too badly.

  2. Written by Kevin Montagne
    on April 13, 2012 at 3:34 am
    Permalink

    I would like to push another avenue for increasing developer adoption. The idea was mentioned in passing near the end of Jarod’s presentation. Certainly a port to Linux will increase the number of developers who have access but its adoption percentage may not be significantly different. If a plugin was available for Eclipse that provided integration with DTrace similar to the language debuggers. It does not necessarily have to be full featured at first but it should be easily extensible and allow access to the native DTrace scripts. I know there is a growing number of languages that support DTrace probes but if plugin was created for Java the underlying framework could be reused for other languages.

    I would argue that the percentage of developers that regularly use a debugger would be significantly lower without IDE integration. How many people enjoy using jdb & gdb? It would be shocking how much more popular printf and its cousins would become.

    I have used DTrace to probe Java applications and even written Java programs that use the DTrace clases to probe other processes. I have never developed a plugin but my assertion would be that somebody that has teamed up with somebody that knew DTrace well an incubator would be soon in coming. I would volunteer to help in developing some requirements and early tester.

    • Written by ahl
      on April 23, 2012 at 8:33 pm
      Permalink

      Kevin,

      Great point and one that I should have highlighted in my post. Making DTrace easy to use, and right at the finger tips of every developer will be a huge step forward.

Subscribe to comments via RSS