UPDATE

Did some more tests. And the compiler does a pretty good job on optimizing, but later more on that.

Sprintf for a single one of your data's takes a few hunderd microseconds, depending on the number. A simple function I made (a bit too simple, it needs a few more checks, but it does the basic):

void intToString(char *buffer, int value) {
    int temp;
    temp = value / 1000;
    buffer[0] = temp + '0';
    value = value - temp * 1000;
    
    temp = value / 100;
    buffer[1] = temp + '0';
    value = value - temp * 100;
    
    temp = value / 10;
    buffer[2] = temp + '0';
    value = value - temp * 10;
    
    temp = value / 1;
    buffer[3] = temp + '0';
    value = value - temp * 1;
    
    buffer[4] = '\0';
}

Does the same in 45us. That is if I let him output an unitialized RAM location. If I do initialize that location, it is another 20 times faster, apparantly the compiler then optimizes quite a bit since it apparantly does know what is going to happen.

Anyway if you want it good, you got to do it yourself. An important lesson in life :P. But the combination is integer divisions being slow on an M0, and the standard function being even slower.

You're my hero Erik! That did the trick! I never expected printf to be so bad, but I guess you learn something new everyday. Could you point me to a link to teach me how to initialize the RAM location for the 20 times speed up? Other than the initialization of 'char datastr0[5]' at the top, I'm not sure what else to do?

Here is the code that worked for me if anyone encounters this problem in the future. I am able to print 6 variables in 340us at 921600 bps, which is only slightly worse than the expected 45us*6 = 270us. This is probably due to the use of ',' and '\n\r'. Most of all, there is no longer any weird delays after printing each group of 6 numbers! :D

#include "mbed.h"

Serial pc(dp16,dp15);

char datastr0[5];
char datastr1[5];
char datastr2[5];
char datastr3[5];
char datastr4[5];
char datastr5[5];

// Credit: Erik Olieman
void intToString(char *buffer, int value) {
    int temp;
    temp = value / 1000;
    buffer[0] = temp + '0';
    value = value - temp * 1000;
    
    temp = value / 100;
    buffer[1] = temp + '0';
    value = value - temp * 100;
    
    temp = value / 10;
    buffer[2] = temp + '0';
    value = value - temp * 10;
    
    temp = value / 1;
    buffer[3] = temp + '0';
    value = value - temp * 1;
    
    buffer[4] = '\0';
}

int main()
{
    pc.baud(921600);
    pc.printf("Working!!\n\r");

    while(1) {
        intToString(datastr0,1114);
        intToString(datastr1,1115);
        intToString(datastr2,1116);
        intToString(datastr3,1117);
        intToString(datastr4,1118);
        intToString(datastr5,1119);
        pc.printf("%s,%s,%s,%s,%s,%s\n\r",datastr0,datastr1,datastr2,datastr3,datastr4,datastr5);

        // pc.printf("%4d,%4d,%4d,%4d,%4d,%4d\n\r",1114,1115,1116,1117,1118,1119);
    }
}

Glad to hear it :).

And if you do it like you got it currently it should already be faster than realistic: The compiler nows the first one you print is 1114. However if this would be for example a value you read from a sensor it will take him 40 us (roughly) to run the intToString function. The only thing you can do about that is send it as binary instead of ascii (which doesn't make your serial protocol easier, it does make it faster though), or use a core M3/M4.