Thread-Specific Resources

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

/* Simplified representation of saved register context */
 
struct cpu_context {
    /* General-purpose registers (x86-64) */
    uint64_t rax, rbx, rcx, rdx;
    uint64_t rsi, rdi, rbp, rsp;
    uint64_t r8, r9, r10, r11;
    uint64_t r12, r13, r14, r15;
    
    /* Instruction pointer */
    uint64_t rip;
    
    /* Flags register */
    uint64_t rflags;
    
    /* Segment registers (important for TLS) */
    uint16_t cs, ss, ds, es, fs, gs;
    uint64_t fs_base, gs_base;  /* Base addresses for FS/GS segments */
    
    /* Extended state (floating point, SIMD) */
    /* This is large: 512 bytes for x87/SSE, up to 2KB+ with AVX-512 */
    uint8_t fpu_state[512];
    uint8_t extended_state[];  /* Variable size based on CPU features */
};
 
/*
 * Context switch saves/restores this entire structure.
 * Modern CPUs can save/restore FPU state lazily to reduce overhead.
 */
 
void context_switch(struct thread *old, struct thread *new) {
    /* Save old thread's state */
    save_cpu_context(&old->cpu_context);
    
    /* Critical: Switch stack pointer */
    /* After this point, we're on the new thread's stack */
    
    /* Restore new thread's state */
    restore_cpu_context(&new->cpu_context);
    
    /* "Return" - but we return to wherever the new thread was suspended */
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void *stack_info_thread(void *arg) {
    int local_var;  /* A variable on this thread's stack */
    
    /* Get the thread's stack info */
    pthread_attr_t attr;
    pthread_getattr_np(pthread_self(), &attr);
    
    void *stack_addr;
    size_t stack_size;
    pthread_attr_getstack(&attr, &stack_addr, &stack_size);
    
    printf("Thread stack:
");
    printf("  Stack base:     %p
", stack_addr);
    printf("  Stack size:     %zu bytes (%.2f MB)
", 
           stack_size, stack_size / (1024.0 * 1024.0));
    printf("  Stack top:      %p
", (char*)stack_addr + stack_size);
    printf("  local_var at:   %p
", &local_var);
    printf("  Stack used:     %zu bytes
", 
           (char*)stack_addr + stack_size - (char*)&local_var);
    
    pthread_attr_destroy(&attr);
    return NULL;
}
 
int main() {
    /* Create thread with custom stack size */
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    
    /* Set stack size to 1 MB */
    size_t custom_size = 1 * 1024 * 1024;
    pthread_attr_setstacksize(&attr, custom_size);
    
    pthread_t thread;
    pthread_create(&thread, &attr, stack_info_thread, NULL);
    pthread_join(thread, NULL);
    
    pthread_attr_destroy(&attr);
    return 0;
}
 
/* Alternatively, allocate your own stack memory */
void create_thread_with_custom_stack(void) {
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    
    /* Allocate aligned stack memory */
    size_t stack_size = 2 * 1024 * 1024;  /* 2 MB */
    void *stack = aligned_alloc(16, stack_size);
    
    /* Set the stack address and size */
    pthread_attr_setstack(&attr, stack, stack_size);
    
    pthread_t thread;
    pthread_create(&thread, &attr, stack_info_thread, NULL);
    
    pthread_join(thread, NULL);
    
    /* Don't forget to free the stack after thread exits */
    free(stack);
    pthread_attr_destroy(&attr);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

#define _GNU_SOURCE
#include <pthread.h>
#include <sched.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/syscall.h>
 
void *thread_with_custom_scheduling(void *arg) {
    /* Get this thread's kernel TID */
    pid_t tid = syscall(SYS_gettid);
    printf("Thread TID: %d
", tid);
    
    /* Get current scheduling policy and priority */
    int policy;
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    
    printf("Scheduling policy: %s
", 
           policy == SCHED_OTHER ? "SCHED_OTHER" :
           policy == SCHED_FIFO ? "SCHED_FIFO" :
           policy == SCHED_RR ? "SCHED_RR" : "Unknown");
    printf("Priority: %d
", param.sched_priority);
    
    /* Get CPU affinity */
    cpu_set_t cpuset;
    pthread_getaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);
    printf("Affinity: ");
    for (int i = 0; i < CPU_SETSIZE; i++) {
        if (CPU_ISSET(i, &cpuset)) {
            printf("CPU%d ", i);
        }
    }
    printf("
");
    
    return NULL;
}
 
int main() {
    pthread_t thread;
    pthread_attr_t attr;
    
    pthread_attr_init(&attr);
    
    /* Set custom CPU affinity - restrict to CPUs 0 and 1 */
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(0, &cpuset);
    CPU_SET(1, &cpuset);
    pthread_attr_setaffinity_np(&attr, sizeof(cpuset), &cpuset);
    
    /* Set scheduling policy and priority (requires root for real-time) */
    /* pthread_attr_setschedpolicy(&attr, SCHED_FIFO); */
    /* struct sched_param param = { .sched_priority = 50 }; */
    /* pthread_attr_setschedparam(&attr, &param); */
    
    pthread_create(&thread, &attr, thread_with_custom_scheduling, NULL);
    pthread_join(thread, NULL);
    
    pthread_attr_destroy(&attr);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
 
void *worker_thread(void *arg) {
    int id = *(int*)arg;
    
    /* Get current signal mask for this thread */
    sigset_t current_mask;
    pthread_sigmask(SIG_BLOCK, NULL, &current_mask);
    
    printf("Thread %d: SIGINT %s
", id,
           sigismember(&current_mask, SIGINT) ? "BLOCKED" : "not blocked");
    printf("Thread %d: SIGTERM %s
", id,
           sigismember(&current_mask, SIGTERM) ? "BLOCKED" : "not blocked");
    
    /* Sleep and see if we receive signals */
    for (int i = 0; i < 5; i++) {
        printf("Thread %d: iteration %d
", id, i);
        sleep(1);
    }
    
    return NULL;
}
 
int main() {
    /* Thread 1: Block SIGINT */
    sigset_t mask1;
    sigemptyset(&mask1);
    sigaddset(&mask1, SIGINT);
    pthread_sigmask(SIG_BLOCK, &mask1, NULL);
    
    int id1 = 1;
    pthread_t t1;
    pthread_create(&t1, NULL, worker_thread, &id1);
    
    /* Thread 2: Different mask - block SIGTERM instead */
    sigset_t mask2;
    sigemptyset(&mask2);
    sigaddset(&mask2, SIGTERM);
    pthread_sigmask(SIG_SETMASK, &mask2, NULL);  /* Replace entire mask */
    
    int id2 = 2;
    pthread_t t2;
    pthread_create(&t2, NULL, worker_thread, &id2);
    
    /* If SIGINT is sent, Thread 1 won't receive it (blocked) */
    /* Thread 2 might receive it (not blocked for SIGINT) */
    
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
 
/* Thread returning a simple value */
void *compute_sum(void *arg) {
    int *numbers = (int*)arg;
    int sum = 0;
    for (int i = 0; i < 5; i++) {
        sum += numbers[i];
    }
    
    /* Return value cast to void* */
    return (void*)(long)sum;
}
 
/* Thread returning a heap-allocated structure */
struct result {
    int sum;
    int max;
    int min;
};
 
void *compute_stats(void *arg) {
    int *numbers = (int*)arg;
    
    struct result *res = malloc(sizeof(struct result));
    res->sum = 0;
    res->max = numbers[0];
    res->min = numbers[0];
    
    for (int i = 0; i < 5; i++) {
        res->sum += numbers[i];
        if (numbers[i] > res->max) res->max = numbers[i];
        if (numbers[i] < res->min) res->min = numbers[i];
    }
    
    /* Return pointer to heap-allocated result */
    return res;  /* Caller must free */
}
 
int main() {
    int data[] = {10, 20, 5, 30, 15};
    pthread_t t1, t2;
    
    pthread_create(&t1, NULL, compute_sum, data);
    pthread_create(&t2, NULL, compute_stats, data);
    
    /* Retrieve exit status from t1 */
    void *ret1;
    pthread_join(t1, &ret1);
    printf("Sum (simple return): %ld
", (long)ret1);
    
    /* Retrieve exit status from t2 */
    void *ret2;
    pthread_join(t2, &ret2);
    struct result *stats = (struct result*)ret2;
    printf("Stats: sum=%d, max=%d, min=%d
", 
           stats->sum, stats->max, stats->min);
    free(stats);  /* Free the heap-allocated result */
    
    return 0;
}