Is this the right way to optimize memory usage? - c

Question

My objective is to optimize memory usage... I've never seen it in any tutorial which leads me to think that this isn't the right way to do it
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct Player {
char* username;
int hp;
int mp;
};
int main(void) {
struct Player test, *p = &test;
p->username = (char*)malloc(50 * sizeof(char));
scanf("%s", p->username);
p->username = realloc(p->username, (strlen(p->username) + 1) * sizeof(char));
printf("%s", p->username);
return 0;
}

Answer 1

right way to optimize memory usage?
Temporary re-used buffers can often be generousness and fixed in size.
Allocating the right-size amount for memory makes sense for member .username for code could be for millions of struct Player.
IOWs, use allocation for the variable size aspects of code. If struct Player was for 2-player chess, a char username[50] size makes sense. For a multi-player universe, char * makes sense.
Rather than call *alloc() twice consider a single right-sized call.
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
// Reasonable upper bound
#define USERNAME_SIZEMAX 50
struct Player {
char* username;
int hp;
int mp;
};
int main(void) {
puts("Enter user name");
// Recommend 2x - useful for leading/trailing spaces & detecting excessive long inputs.
char buf[USERNAME_SIZEMAX * 50];
if (fgets(buf, sizeof buf, stdin) == NULL) {
puts("No input");
} else {
trim(buf); // TBD code to lop off leading/trailing spaces
if (!valid_name(buf)) { // TBD code to validate the `name`
printf("Bad input \"%s\"\n", buf);
} else {
struct Player test = { 0 }; // fully populate
test.username = malloc(strlen(buf) + 1);
// Maybe add NULL check here
strcpy(test.username, buf);
// Oh happy day!
printf("%s", p->username);
return EXIT_SUCCESS;
}
}
return EXIT_FAILURE;
}

Answer 2

Some tips:
a) the example code is too small to matter
b) never use malloc() for something that you will always want one of. Instead, pre-allocate (e.g. as a global variable) or (if it's small enough) use a local variable to avoid the overhead of malloc(). E.g.:
int main(void) {
struct Player test, *p = &test;
char userName[50];
p->username = userName;
c) Don't spread data all over the place. You want all the data in the same place (in the least number of cache lines, with pieces of data that are used at the same time as close to each other as possible). One way to do that is to combine multiple items. E.g.:
struct Player {
char username[50];
int hp;
int mp;
};
int main(void) {
struct Player test, *p = &test;
d) If something takes (at most) 50 chars of memory; don't bother using realloc() to waste CPU time and potentially waste more memory. Don't forget that the internal code for malloc() and realloc() will add meta-data to each allocated piece of memory that is likely to cost an extra 16 bytes or more.
In general; for performance, malloc() and realloc() (and new() and ...) should be completely avoided (especially for larger programs). They spread data "randomly" everywhere and destroy any hope of getting good locality (which is important for minimising multiple very expensive things - cache misses, TLB misses, page faults, swap space usage, ...).
Note: scanf() and gets() should also be banned. They provide no way to prevent buffer overflows (e.g. the user providing more than 50 characters when there's only enough memory allocated for 50 characters, for the purpose of deliberately trashing/corrupting other data), which results in huge gaping security holes.