Folding@home

Inferring the Rate-Length Law of Protein Folding

Guest post from Dr. Gregory Bowman, University of California, Berkeley

One objective of the Folding@home project is to provide insight into general protein folding mechanisms that hold across a variety of systems.  For example, how much slower, on average, do longer proteins take to fold than shorter ones?  To address questions like this, Lane and Pande recently developed a theoretical framework for testing different models of the scaling of protein folding times with chain length against experimental observations (line here).  One of their major conclusions is that there is insufficient data to distinguish between many of the possible models.  All is not lost though.  The framework they developed also allows them to point out the types of measurements that need to be made to conclusively determine which of the models that have been proposed is best.  In the future, it will be exciting to begin both computational and experimental studies of these systems.

In memory of Gordon T. and Rose Anne Smitheman

Today, we have a guest post by Team MaximumPC.  Two new work unit servers have been funded by the Folding@home (FAH) community in memory of Gordon T. Smitheman and his wife, Rose Anne.

Gordon, a dedicated member (username: gsmitheman) of Team MaximumPC (#11108), passed away January 25, 2012.  His death came just a couple of months after his beloved Rose passed away on November 27, 2011 after a battle with pancreatic cancer.

As evidenced by his 17,000 posts in the MaximumPC Folding Forum, Gordon was very active at promoting the project.  It wasn’t just the quantity, but the quality of his posts that made him a revered teammate.  His calling card was recognizing others: welcoming new folders, celebrating personal and team milestones, coordinating contests with prizes of hardware donated by him and others, and other posts that encouraged active participation in the forum.  He also visited other teams’ forums to extend greetings and recognize their milestones.

The impact of losing such a valuable teammate and genuinely kind-hearted person was hard to put into words, but many did their best in a forum thread titled “We Lost One of F@H's Greatest Champions - Gordon Smitheman.”

Teammate and FAH beta tester Michael “Doc” McCord, MD proposed a server purchase as a tribute to the tireless dedication Gordon demonstrated in promoting folding. The generosity of donors, representing numerous teams throughout the world, resulted in the funds to purchase not one, but two servers for the project.

Gordon greatly valued his family.  It was one of the few things that took precedence over folding.  But, his family was very supportive of his FAH activities.  It was for that reason naming the second server after Gordon’s wife, Rose, was a natural choice.

Many thanks to Dr. Pande, Dr. McCord, Team MaximumPC, and everyone who donated funds that made this commemoration possible.  Fold On!

FAH bench – FAH core/OpenMM-based benchmark for your GPU

As previously blogged, FAHBench is the official Folding@Home GPU benchmark. It measures the compute performance of GPUs for Folding@Home. In addition, by use of a loadable DLL system, it provides vendors and skilled hackers with a method make customized-plugins and test their results.

Info
Current release 0.5 – Jan/30/2013 (Stable)
-Updates:
-Minor performance improvements
Download Link (You must agree to Disclaimer on the bottom)

Usage
The program runs from the command line – allowing you to set up runs as needed. For example:
FAHBench.exe -deviceId 0 -platform OpenCL -precision single
Uses the OpenCL platform on the 0th (0-indexed) device, in single precision mode
NVIDIA cards can use either the OpenCL or the CUDA platform. ATI cards must use the OpenCL platform.

Contact
Yutong Zhao (proteneer at gmail)

Requirements
OpenCL:
Windows (tested on Win7, untested on others)
Latest NVIDIA/ATI Drivers (Exclusive-Or)
CUDA:
Microsoft has deprecated MSVS 2008 Express, the CUDA platform is no longer supported until NVIDIA ships a built-in JIT compiler.

Current Stats
These numbers measure the expected number of nanoseconds per day on a realistic simulation system. Time step used in integration is set to 2 femtoseconds.

System 1: DHFR, Single Precision

OpenCL
   HD7970: (Explicit 18.1 ns/day | Implicit 101.3 ns/day)
Tesla K20: (Explicit 18.1 ns/day | Implicit  84.5 ns/day)
GTX 660Ti: (Explicit 16.1 ns/day | Implicit  77.0 ns/day)
   HD4000: (Explicit  3.2 ns/day | Implicit  18.0 ns/day)
 i7-3770K: (Explicit  3.1 ns/day | Implicit   3.4 ns/day)

(more to come)

 

Developers
It is very easy to test your own modifications the source code. Though note that the GPU code in OpenMM is LGPL – you must be able to provide us (the OpenMM developers) changes to the source code upon request.

1. Download the latest OpenMM from the svn repo: svn checkout https://simtk.org/svn/openmm 
2. Build the projects OpenMM OpenMMSerialization OpenMMCUDA OpenMMOpenCL using CMake and VS2008
3. Replace the .dlls in the FAHBench folder with your own

It is not recommended to directly use FAHBench to ensure accuracy. OpenMM has its own suite of detailed unit tests that can pinpoint problems much easier. FAHBench serves as a final check.

Links
Folding@Home
OpenMM

Disclaimer
IN NO EVENT SHALL THE AUTHORS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF STANFORD UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. THE AUTHORS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOTLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION PROVIDED HEREUNDER IS PROVIDED "AS IS". THE AUTHORS AND STANFORD UNIVERSITY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

Introducing Folding@Home Core 17 – GPU zeta core

As also announced on OpenMM/Folding@home programmer Yutong "proteneer" Zhao's web site, we are happy to announce that Folding@Home Core 17 has entered Beta. Externally, you probably won’t notice too much of a difference. Internally, this is a complete overhaul that brings many new features, and sets a strong foundation for the future of GPU core development. In addition, the restructuring brings much tighter integration of the core with the rest of the development within Folding@Home.

We’re also introducing an explicit solvent project (p7661) as part of the Beta. To keep the credit assigned to these projects consistent with previous explicit solvent work units run on CPUs, we are also awarding a quick return bonus with a k-factor of 0.75. This reflects the additional scientific value of these units, and keeps the Folding@Home credit awards consistent across different architectures.

Usage:
This is a still a very new core, a lot of the features have yet to be fully tested. Thus, as is the beta policy, no official support is given. You must enable the -beta flag on FAHClient, ie. set client-type=beta. If you’re using client 7.2.x or earlier, there are two options:
1. Specify -gpu-vendor=XXX, where XXX is either nvidia or ati
2. If -gpu-vendor is not specified, the core will automatically guess the platformId.
Otherwise, 7.3.6 lets you specify the particular -gpu-vendor as an option
Supported NVIDIA cards: Fermi or better (Titan does not work atm, as NVIDIA needs to publish new OpenCL drivers)
Supported ATI cards: HD5000 or better
As always, please use the latest drivers (Win XP is NOT supported due to super-old AMD drivers).

Key Features:
Cleaner Code
We have deprecated several layers of GROMACs and other wrappers as the old architecture severely limited the types of simulations that can be run. Much of the work on the new core has been to replace existing features. The resulting code is now more streamlined and integrated. We also anticipate that this major re-design will allow us to introduce new features into the Folding@Home much faster.

Serialization
We have introduced a new serialization mechanism that allows Pande Group researchers to setup significantly more diverse simulations. Pande Group researchers can now easily setup jobs and projects using Python (with a much richer and easier to use set of libraries), while the core maintains its speed by virtue of being written in C++. We achieved this using a serialization technique, whereby all details of a simulation are encapsulated using a standardized format that is then be passed around between language barriers. This also drastically reduces the dependencies needed by the Work Server and other parts of Folding@Home.

A single unified core now runs both NVIDIA and AMD cards
Before we had two development branches for NVIDIA and AMD cards. It was a difficult and cumbersome task to debug and maintain. We couldn’t easily mix runs and gens produced by different GPU types. Now, using OpenCL, a single core supports not only AMD and NVIDIA, but theoretically any OpenCL-capable device.

Improved Stability
By reducing the amount of boilerplate code, we’ve also increased the robustness and stability of the core. The log files should also now be much more informative. There are also a lot of useful debugging features built right into the core to help PG developers nail down hard to find bugs.

Extra special thanks to our testers:
Jesse_V, k1wi, artoar_11, bollix, ChelseaOilman, bruce, Demonfang, Grandpa_01, EXT64, Flaschie, HayesK, jimerickson, mmonnin_, P5-133XL, Patriot, rhavern, sc0tty8, SodaAnt, SolidSteel144, EvilPenguin, art_l_j_PlanetAMD64, thews, cam51037, Pin, muziqaz, baz657, PantherX, QINSP, Schro, and hootis.

OpenMM Youtube channel

OpenMM is a key part of Folding@home, powering its GPU cores.  You can learn more about OpenMM at its youtube page, which includes technical videos on how you can incorporate OpenMM into your code.  It also includes an introduction to Markov State Models (MSMs), which is a key technology used in Folding@home.

http://www.youtube.com/user/SimbiosOpenMM

 

  

FAH paper listed amongst best of 2012 by Biophysical Journal

Biophysical Journal announced their "Best of 2012" paper collection.  We were excited that one of our papers was included.  That work, "Protein Folding is Mechanistically Robust" investigates how key aspects of FAH technology (MSMs) can yield new insights into protein folding in some unexpected ways.  Congratulations to Jeffery Weber for his work.  We've posted the technical abstract below as well.

ABSTRACT.  Markov state models (MSMs) have proven to be useful tools in simulating large and slowly-relaxing biological systems like proteins. MSMs model proteins through dynamics on a discrete-state energy landscape, allowing molecules to effectively sample large regions of phase space. In this work, we use aspects of MSMs to ask: is protein folding mechanistically robust? We first provide a definition of mechanism in the context of Markovian models, and we later use perturbation theory and the concept of parametric sloppiness to show that parts of the MSM eigenspectrum are resistant to perturbation. We introduce a new, to our knowledge, Bayesian metric by which eigenspectrum robustness can be evaluated, and we discuss the implications of mechanistic robustness and possible new applications of MSMs to understanding biophysical phenomena.

 

Past the 10 Petaflop scale

Folding@home has historically been an extremely powerful computing resource, hitting many major computing milestones.  For example, we were awarded a Guinness World Record for being the first to reach a petaflop (10^15 floating point operations per second).

We keep track of the power of Folding@home on our osstats page.  Recently, we found an issue with our reporting.  In particular, we were investigating a major under-reporting (OSX stats reported that there were no OSX machines at all). A few months ago, Christian Schwantes (FAH Team member) rewrote our main stats scripts and he fixed a very old bug in the stats reporting. That bug had a workaround in the osstats2 page, so now the workaround was failing and that led to finally getting osstats2 working. 

After checking the db with the raw files from the work servers (it's an important check that we can know what the right answer is from this more laborious manual process of going through the WS logs), this result is now correct, fixing the previous under-reporting. We also now are keeping better track of the Fermi (and later) class of NV GPUs. We were under-reporting their FLOP count and that alone was what make a huge difference in the FLOPs reported.

The upshot of all of this is that we now are no longer under-reporting our stats and the reported FLOPs has gone up significantly, to about 12 PFLOPs.  This puts Folding@home past the 10 PetaFLOP scale, which is itself a very significant amount of computer power.

For more information, please see our FLOPS FAQ, whichis useful in discussing this topic, which is surprisingly complicated.

New FAH client, web site, and video

We've rolled out the latest version 7.3 client to the main web site.  This new client should be much easier to install and comes with a new web interface which is simpler and easier to use.  

But in addition, we've been trying to communicate our goals and mission more clearly.  Our first steps there are a new web site and a new video.  The video in particular is something that we're all very excited about, since it explains to a broad audience what FAH is all about.

 

New methods development

Guest post from Dr. Greg Bowman, University of California, Berkeley

 

Markov state models (MSMs) are a powerful approach for investigating the dynamics of proteins and other biomolecules. The Folding@home team has helped to pioneer the development of these methods and continues to make important contributions to their further development.  For example, the Huang lab at the Hong Kong University of Science and Technology has created an exciting new method for coarse-graining Markov models (the paper is available here).

One of the major challenges in this area is that the high-resolution Markov models capable of making quantitative predictions of experiments often have tens of thousands of parts.  As you can imagine, it is hard to look at each of these parts and the interactions between them to understand the model.  Therefore, it is valuable to create a new model with, say, a dozen states that still captures much of the behavior of the more complex model. 

The new method from the Huang lab makes use of a mathematical principle called a Nystrom expansion to build more accurate coarse-grained models.  The key advantage of this approach is that one can quickly identify the most important pieces of a model and prove that the remaining pieces can safely be ignored (or merged into the more important parts).  As a proof of principle, the Huang lab has shown they can build much better models for a few small proteins than is possible with previous methods.

 

 

Known stats issue under investigation

We're having an issue with the interaction between our web main server and stats db.  We are looking into this.  It looks like the obvious fixes haven't worked, so we are escalating.  

The stats are being input fine, it's just with the reporting on the main web page.  If this continues, we may take the main web page stats pages down, but 3rd party stats should still work and be regularly updated.

As always, we'll update you on our progress with this issue.