16. Generic and Meta Programming with Templates

Templates are a mechanism provided by the C++ language to parametrize code over various types and constants with compile-time code specialization for each instance. Charm++ allows developers to implement various entities using C++ templates to gain their advantages in abstraction, flexibility, and performance. Because the Charm++ runtime system requires some generated code for each entity type that is used in a program, template entities must each have a declaration in a .ci file, a definition in a C++ header, and declarations of their instantiations in one or more .ci files.The first step to implementing a templated Charm++ entity is declaring it as such in a .ci file. This declaration takes the same form as any C++ template: the template keyword, a list of template parameters surrounded by angle brackets, and the normal declaration of the entity with possible reference to the template parameters. The Charm++ interface translator will generate corresponding templated code for the entity, similar to what it would generate for a non-templated entity of the same kind. Differences in how one uses this generated code are described below. A message template might be declared as follows:

module A {
  template <class DType, int N=3>
  message TMessage;

Note that default template parameters are supported. If one wished to include variable-length arrays in a message template, those can be accomodated as well:

module B {
  template <class DType>
  message TVarMessage {
    DType payload[];

Similarly, chare class templates (for various kinds of chares) would be written:

module C {
  template <typename T>
  chare TChare {
    entry TChare();
    entry void doStuff(T t);

  template <typename U>
  group TGroup {
    entry TGroup();
    entry void doSomethingElse(U u, int n);

  template <typename V, int s>
  array [2D] TArray {
    entry TArray(V v);

  template <typename W>
  nodegroup TNodeGroup {
    entry TNodeGroup();
    entry void doAnotherThing(W w);

Entry method templates are declared like so:

module D {
    array [1D] libArray {
        entry libArray(int _dataSize);
        template <typename T>
        entry void doSomething(T t, CkCallback redCB);

The definition of templated Charm++ entities works almost identically to the definition of non-template entities, with the addition of the expected template signature:

// A.h
#include ``A.decl.h''

template <class DType, int N=3>

struct TMessage : public CMessage_TMessage<DType, N> {
  DType d[N];

#include ``A.def.h''

The distinguishing change is the additional requirement to include parts of the generated .def.h file that relate to the templates being defined. This exposes the generated code that provides registration and other supporting routines to client code that will need to instantiate it. As with C++ template code in general, the entire definition of the templated entity must be visible to the code that eventually references it to allow instantiation. In circumstances where module A contains only template code, some source file including A.def.h without the template macro will still have to be compiled and linked to incorporate module-level generated code.

Code that references particular templated entities needs to ask the interface translator to instantiate registration and delivery code for those entities. This is accomplished by a declaration in a .ci file that names the entity and the actual template arguments for which an instantiation is desired.

For the message and chare templates described above, a few instantiations might look like

module D {
  extern module A;
  message TMessage<float, 7>;
  message TMessage<double>;
  message TMessage<int, 1>;

  extern module C;
  array [2D] TArray<std::string, 4>;
  group TGroup<char>;

Instantiations of entry method templates are slightly more complex, because they must specify the chare class containing them. The template arguments are also specified directly in the method's parameters, rather than as distinct template arguments.

module E {
  extern module D;

  // syntax: extern entry void chareClassName templateEntryMethodName(list, of, actual, arguments);
  extern entry void libArray doSomething(int&, CkCallback redCB);

To enable generic programming using Charm++ entities, we define a number of type trait utilities. These can be used to determine at compile-time if a type is a certain kind of Charm++ type:

#include "charm++_type_traits.h"

// Is T a chare array proxy?

using result = charmxx::is_array_proxy<T>;

// Is T a group proxy?

using result = charmxx::is_group_proxy<T>;

// Is T a node group proxy?

using result = charmxx::is_node_group_proxy<T>;

// Is T a chare proxy?

using result = charmxx::is_chare_proxy<T>;

// Is T a bound array?

using result = charmxx::is_bound_array<T>;

// Does T have a PUP routine defined for it?

using result = charmxx::is_pupable<T>;