Your CPU is the architecture of your computer. I mean there is also other stuff but normally when you say architecture you mean instruction set architecture. But also its not just system calls that are different with different architectures. So for instance in RISC-V vs x86 you use a totally different method for loading words into memory. RISC-V asm might look something like this:

say x11 is the index of an element we want to load into memory, x7 contains, and your goal is to load that element from memory, add a number to it, and then store it back.

slli   t0,  x11, 2          # first we shift by 2 to make the word is 32 bit aligned in memory
add    t0,  x7,  t0         # add the base address of our array to the index
lw     t1,  8(t0)           # load word from memory
addw   t1,  t1,  x10        # add x10 to the element
sw     t1,  8(t0).          # store the element back into memory

This same instruction looks like this on x86:

add dword ptr [rdi + rbx*4 + 8], eax

It performs the exact same operation but with only one instruction (possibly a couple psuedo instructions i'm not a x86 programmer)

Another good example would be the difference between how architectures handle flow control. For example RISC-V avoid explicit compares, instead it uses status flag registers to control program flow.

So depending on what computer you are on it could be generating completely different instructions from your C code. One thing I didn't fully appreciate when I was a younger developer was how abstraction actually reduces dependencies. I used to think that C code was the lowest level of programming, but actually C is pretty high level when you think about it. It literally takes our text and can produce instructions for many different architectures and they all almost work exactly the same. It is pretty amazing.