C/C++ - Cosa fanno "a basso livello" le funzioni *sleep() ?

Ciao a tutti!
Ho aperto questa domanda per chiedere cosa fanno realmente le funzioni tipo sleep(). Ok, so che mettono in pausa il processo per il tempo indicato come parametro, ma più precisamente?
Chiedo questo perchè provando a misurare il tempo di esecuzione di un programma che ha una sleep() all'interno, il programma in questione mi stampa sempre 0.
Il programma in questione è questo:

#include <stdio.h>
#include <time.h>

float diff(clock_t, clock_t); 

int main(void) {
	clock_t start, end; 
	
	start = clock(); 
	
	sleep(2); 
	
	end = clock(); 
	
	printf("%gs\n",  diff(end, start));
	
	return 0; 
}
	
float diff(clock_t end, clock_t start) {
	return ((float)(end - start)) / CLOCKS_PER_SEC;
}

Questo semestre ho Sistemi Operativi, e mi viene da pensare che la sleep() metta il processo in attesa di un segnale che lo risvegli, ma sono mie supposizioni, ovviamente.
Aspetto qualche chiarimento, grazie a tutti.

In Windows una Sleep causa il fatto che il thread viene posto in condizione

unrunnable

Quando il tempo è trascorso, lo scheduler lo pone in condizione

ready-to-run

Penso che Linux faccia in modo simile

In Unix dipende dall'implementazione; un modo di farlo e' utilizzare alarm.

static void
sig_alrm(int signo)
{
    /* nothing to do, just returning wakes up sigsuspend() */
}

unsigned int
sleep(unsigned int nsecs)
{
    struct sigaction    newact, oldact;
    sigset_t            newmask, oldmask, suspmask;
    unsigned int        unslept;

    /* set our handler, save previous information */
    newact.sa_handler = sig_alrm;
    sigemptyset(&newact.sa_mask);
    newact.sa_flags = 0;
    sigaction(SIGALRM, &newact, &oldact);

    /* block SIGALRM and save current signal mask */
    sigemptyset(&newmask);
    sigaddset(&newmask, SIGALRM);
    sigprocmask(SIG_BLOCK, &newmask, &oldmask);

    alarm(nsecs);

    suspmask = oldmask;
    sigdelset(&suspmask, SIGALRM);    /* make sure SIGALRM isn't blocked */
    sigsuspend(&suspmask);            /* wait for any signal to be caught */

    /* some signal has been caught,   SIGALRM is now blocked */

    unslept = alarm(0);
    sigaction(SIGALRM, &oldact, NULL);  /* reset previous action */

    /* reset signal mask, which unblocks SIGALRM */
    sigprocmask(SIG_SETMASK, &oldmask, NULL);
    return(unslept);
}

Il codice non e' mio, e' preso da Advanced Programming in the Unix Environment. Alarm e' una syscall che genera un segnale allo scadere del tempo prefissato ed e' gestita dal kernel (che ha il suo modo di tenere traccia del tempo che passa). Sigsuspend si occupa di sospendere il processo fintanto che un segnale non viene ricevuto.