Sum a list of string numbers
I see a few things that may help you improve your code.

Add some error checking

Many of the calls used in the code, including fstat and malloc can fail.  It's generally better to check for and handle such errors instead of ignoring them.  Even though your main concern is performance, these calls are only made once and so will add almost nothing to the runtime.

Here's an alternative main showing how that might look:

int main() {
    struct stat sb;
    char *data;
    if (fstat(STDIN_FILENO, &amp;sb) != 0 || (data = (char *)mmap(0, sb.st_size, PROT_READ, MAP_SHARED, STDIN_FILENO, 0)) == nullptr) {
        perror("Error reading stdin");
        return 1;
    } 
    std::cout &lt;&lt; sum(data, sb.st_size) &lt;&lt; '\n';
}


Avoid the use of global variables

The data variable is used within read_data and the poorly named process().  It's generally better to explicitly pass variables your function will need or declare them within the appropriately smallest possible scope rather than using the vague implicit linkage of a global variable.  

Avoid premature optimization

On my machine, omitting the use of the unlikely macro and the alignas(16) made no difference in the resulting speed of the program.  Generally, I only resort to such things if there is a measurable effect and performance is more important than portability.  Perhaps you've already measured and made this determination and perhaps the results are different on your machine.

Consider an alternative algorithm

An alternative algorithm, which yields times very similar to the ones with your original, might be employed here.  In particular, we could process the file from the end to the beginning instead of the usual direction.  This allows us to efficiently convert each number, only adding the converted number when encountering a newline.  Note that this also essentially throws away the first number (which is the count of numbers to follow) which is the correct behavior in this case, since that number is not intended to be included in the sum.  Here's one version of the sum routine for that algorithm:

int sum(const char *test, std::size_t len) {
    int result{0};
    int n{0};
    int mult{1};
    // start from the back and add digits
    for (const char *ptr = test+len-1; ptr &gt;= test; --ptr) {
        switch(*ptr) {
            case '\n':
                result += n;
                n=0;
                mult=1;
                break;
            case '-':
                n = -n;
                break;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                n += mult * (*ptr - '0');
                mult *= 10;
                break;
            default:
                std::cerr &lt;&lt; "Malformed input\n";
                exit(1);
        }
    }
    return result;
}