ctrychta / ctrychta.github.io Goto Github PK

I like the general idea a lot but I think it should be less narrow in scope. For instance instead of just indicating the branch hints it should be a general attribute that can give compilers hints about how we want our code generated. This allows us to tailor the hints for CPUs that have concepts beyond the core CPU sets.
For this I'll use cpphint which could be replaced by cpuhint or any other better name (ch if the other is too long). The idea is to describe to the optimizer within the compiler hints about how to optimize the code. Branching is just one aspect but it could also describe how to layout the objects within cache lines. It could also indicate that we want to hold onto this object in a L1 cache since we will be depending on this variable a lot within our algorithm.
The optimizer will of course take these as hints and will not force its' use unless a specific compiler option overrides the internal state. This allows all the hints or none of the hints or even some of the hints to be used. This would allow for performance comparisons during optimization testing. This would help determine if the hints are in the best places and that they are achieving better performance.
These examples can be expanded but it should attempt to be a general platform where we can use cpp to completely describe not just the solution but how we are thinking about the problem. It jumps to the next level by providing the optimizer with contextual information that can not be determined by the code alone.

Some examples:

// If statement using hint to indicate that this if is most likely.
if [cpphint: likely] b < c
{
  a = 6;
} else {
  a = 9;
}

// Data structure where some of the values are used enough that it should stay in the
// fastest cache
struct
{
 int counter;  [cpphint: L1cache]
 int data;
 int important; [cpphint: L1cache]
};

// Data structure where this value is read from a network recv
// and should be placed in a way to get the data quickly from the network bus. 
struct
{
  int index; [cpphint: NetworkRead]
};

// Data structure where the data is a network value where the regular endian is not the same
// as the default for the cpu.
struct
{
  int value; [cpphint: bigendian]
};