{"id":1313,"date":"2014-12-15T22:12:20","date_gmt":"2014-12-15T22:12:20","guid":{"rendered":"http:\/\/www.codergears.com\/Blog\/?p=1313"},"modified":"2014-12-18T20:40:02","modified_gmt":"2014-12-18T20:40:02","slug":"lessons-to-learn-from-john-carmack-and-oculus-developement-team-when-using-the-modern-c-approach","status":"publish","type":"post","link":"https:\/\/codergears.com\/Blog\/?p=1313","title":{"rendered":"Lessons to learn from Oculus development team when using the “Modern C++” approach."},"content":{"rendered":"

In the previous post about Doom3<\/a>, we discovered that it was developed using the “C with Classes” approach. John Carmack is\u00a0the main developer and it was between 2000 and 2004, what explains why “Modern C++” approach was not adopted. And, even if “C with Classes” is not recommended, he made some good decisions to have clean code.<\/p>\n

John Carmack is now the oculus VR<\/a> CTO, Oculus VR\u00a0is an American virtual reality\u00a0technology company founded by Palmer Luckey and Brendan Iribe. Their first product, still in development, is the\u00a0Oculus Rift, a\u00a0head-mounted display\u00a0for immersive virtual reality\u00a0(VR).<\/p>\n

Oculus provides an SDK\u00a0which includes its source code, it’s developed using C++. \u00a0For this project the Modern C++ approach was adopted. Let’s discover some design and implementation choices of its primary architect<\/span>\u00a0Michael Antonov.<\/p>\n

1- Use namespaces to modularize\u00a0the SDK<\/strong><\/p>\n

Namespaces were introduced to the C++ Standard in 1995\u00a0and usually they are most often used to avoid\u00a0naming collisions. Although namespaces are used extensively in recent C++ code, most older code does not use this artifact.
\nNamespaces are useful to modularize your projects, to make it more readable and maintainable. Here’s the list of all namespaces defined in the oculus SDK:
\n\"ovr1\"<\/a><\/p>\n

2-\u00a0Minimize the use of global variables and functions<\/strong><\/p>\n

The SDK defines few global functions; most of them are the exported ones. Even if a function is just an utility, it’s better to add it in a \u00a0class as static to group utilities by category.<\/p>\n

3- Modern C++ doesn’t imply necessarly the overuse of templates<\/strong><\/p>\n

Andrei Alexandrescu says about the Modern C++ design:<\/p>\n

\n

Modern C++ Design defines and systematically uses\u00a0<\/span>generic components<\/i>\u00a0– highly flexible design artifacts that are mixable and matchable to obtain rich behaviors with a small, orthogonal body of code.<\/span><\/p>\n<\/blockquote>\n

Modern C++ has a close relation with generic programming; probably it\u2019s the reason that makes many developers neglect the modern C++ approach. They think that the code will be mostly implemented as templates, which makes the code difficult to read and maintain.<\/p>\n

In the SDK, the templates represent only 20% of all types defined and most of them are related to the technical layer.<\/p>\n

The following CQLinq <\/a>query give us the types defined by the SDK:<\/p>\n

\"ovr3\"<\/a><\/p>\n

 <\/p>\n

It’s true that some Modern C++ libraries like Boost mainly define their classes as templates to be as the most generic as possible. However, in many other applications it’s not necessarily the case. You could use templates when the genericity is suitable and needed.<\/p>\n

4- Don’t repeat yourself<\/strong><\/p>\n

Repeating boilerplate code makes maintenance difficult, and allows all kinds of mistakes. With generic programming you can avoid harmful repetition. Think about using generic everywhere, the code is similar and differs only in types manipulated.<\/p>\n

The SDK defines a templated singleton, to avoid the same singleton code in many places:<\/p>\n

\"ovr5\"<\/a><\/p>\n

5- Allocation and RAII<\/b><\/span><\/p>\n

RAII is a C++ idiom\u00a0which binds the life cycle of a resource \u00a0to the lifetime of an object with automatic storage duration, which guarantees that all resources are cleaned up when the object goes out of scope, in reverse order of acquisition. This leverages the language to eliminate resource leaks and guarantee exception safety.<\/p>\n

To manage allocation, the oculus development team defines its reference counted class OVR::RefCountBase which is a base class for classes that require thread-safe reference counting; it also overrides the new and delete operators to use MemoryHeap.<\/p>\n

Many classes inherit from it to manage their life cycle.<\/p>\n

\"ovr8\"<\/a><\/p>\n

These ref counted classes are used through the\u00a0Reference Counted template pointer OVR::Ptr<C> which contains the logic of AddRef and Release methods.<\/p>\n

With these allocation utility classes, the SDK users will not care about releasing the pointers used, or spending time to resolve memory management problems due to the use of multithreading. The classes implemented by the SDK free the developers from the memory management problems.<\/p>\n

6- Prefer static polymorphism to dynamic polymorphism<\/strong><\/p>\n

In classic C++, the dynamic polymorphism is generally overused, which implies the use of inheritance, and the use of the virtual table at runtime to know the method of each child class to invoke. On the other side, static polymorphism is completely resolved at compile time.<\/p>\n

For example the SDK defines the Shader class for Direct 3D version 10, Direct3D version 11 and OpenGL.<\/p>\n

\"ovr9\"<\/a><\/p>\n

In contrast to\u00a0\u00a0classic C++ \u00a0they do not have a\u00a0common base class, so the RTTI could not be used to decide the\u00a0methods of which one will be used at runtime.<\/p>\n

Here’s a snippet of the implementation of SharedImpl class. This class has two template parameters and \u00a0the decision of which Shader to use is done at compile time\u00a0by specifying the D3DShaderType when an instance is created.<\/p>\n

\"ovr17\"<\/a><\/p>\n

In Modern C++, static polymorphism is preferred to the dynamic one, it makes the code more flexible, no need to have an inheritance relation between classes, which enforce the low coupling.<\/p>\n

7- Separate\u00a0data model from treatments<\/strong><\/p>\n

The oculus SDK defines many structs for its data model, here is the CppDepend metric view<\/a> which shows in blue all of them.<\/p>\n

\"ovr2\"<\/a><\/p>\n

Let’s take as example ovrSensorData struct from the SDK, and suppose it was defined as class containing also the treatments. If we need to use these data in another context that we need to add other methods, we will have a not cohesive class after few evolutions.<\/p>\n

8- Use some most common modern C++ techniques\u00a0<\/strong><\/p>\n

The Modern C++ design introduced many idioms, some of them are easy to understand and implement, others are difficult and makes the code not easy to read and maintain.<\/p>\n

You can focus only on the most common used ones; the oculus SDK uses mainly Traits <\/a>and Policy-based design<\/a> techniques. Here’s an example of a class from the SDK using them:<\/p>\n

\"ovr10\"<\/a><\/p>\n

Don’t force yourself to use all the Modern C++ idioms like SFINAE <\/a>or other advanced ones, unless you really need to.<\/p>\n

9- It’s not mandatory to use Exception handling<\/strong><\/p>\n

Even if many Modern C++ resources recommend the use of exceptions they are not used in many known open source projects. The exceptions provide a powerful mechanism to report errors. However, it\u2019s not easy to write an exception safety code.<\/p>\n

The oculus SDK developers prefer to not use them.<\/p>\n

10- And specially don’t forget to provide recurrent technical layer needs<\/strong><\/p>\n

The classes related to the technical layer are generally the most used ones as shown by this following CQLinq query:<\/p>\n

\"ovr18\"<\/a><\/p>\n

In some projects\u00a0the C++ developers\u00a0\u00a0spend most of their development time fighting with the technical layer.<\/p>\n

As the decision taken for Doom3, the oculus SDK provides all needed low level classes, powerful String and StringBuilder classes are\u00a0implemented, many useful classes concerning multithreading, memory management, containers are provided, which makes the task very easy for the SDK users.<\/p>\n

Summary:<\/strong><\/p>\n

In the oculus SDK source code and as Doom3, \u00a0the priority is to make the life easy for developers by:<\/p>\n