kernel_uniqueptr.h

Go to the documentation of this file.

#pragma once
#ifndef KERNEL_UNIQUEPTR_H
#define KERNEL_UNIQUEPTR_H
 
#include <dlfcn.h>
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/wait.h>
#include <semaphore.h>
#include <stdbool.h>
#include <netdb.h>
#include <arpa/inet.h>
#include "kernel_print.h"
#include "kernel_engine.h"
 
#include "../src/ename.c.inc"  // 파일의 상대 경로로 수정
 
 
#define BUF_SIZE 100
#define NUM_THREADS 3
#define MAX_STRING_SIZE 100
 
#define RETAIN_SHARED_PTR(ptr) retain_shared_ptr(ptr);
#define RELEASE_SHARED_PTR(ptr) release_shared_ptr(ptr);
 
void default_deleter(void *ptr) {
    free(ptr);
}
 
typedef struct {
    void *ptr;               
    int *ref_count;          
    pthread_mutex_t *mutex;  
    void (*deleter)(void*);  
} SharedPtr;
 
typedef struct {
    void *ptr;               
    void (*deleter)(void*);  
} UniquePtr;
 
SharedPtr create_shared_ptr(size_t size, void (*deleter)(void*)) {
    SharedPtr sp;
    sp.ptr = malloc(size);
    sp.ref_count = (int*)malloc(sizeof(int));
    *(sp.ref_count) = 1;
    sp.mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
    sp.deleter = deleter ? deleter : default_deleter;
    pthread_mutex_init(sp.mutex, NULL);
 
    return sp;
}
 
UniquePtr create_unique_ptr(size_t size, void (*deleter)(void*)) {
    UniquePtr up;
    up.ptr = malloc(size);
    up.deleter = deleter ? deleter : default_deleter;
    return up;
}
 
void retain_shared_ptr(SharedPtr *sp) {
    pthread_mutex_lock(sp->mutex);
    (*(sp->ref_count))++;
    pthread_mutex_unlock(sp->mutex);
}
 
void release_shared_ptr(SharedPtr *sp) {
    if (sp->ptr == NULL) {
        safe_kernel_printf("SharedPtr is already released\n");
        return;
    }
 
    sp->deleter(sp->ptr);
    sp->ptr = NULL;
 
    free(sp->ref_count);
    sp->ref_count = NULL;
    pthread_mutex_destroy(sp->mutex);
    free(sp->mutex);
    sp->mutex = NULL;
}
 
void release_unique_ptr(UniquePtr *up) {
    if (up->ptr) {
        up->deleter(up->ptr);
        up->ptr = NULL;
    }
}
 
UniquePtr transfer_unique_ptr(UniquePtr *up) {
    UniquePtr new_up = *up;
    up->ptr = NULL;
    return new_up;
}
 
void* thread_function_shared(void* arg) {
    SharedPtr *sp = (SharedPtr*)arg;
    retain_shared_ptr(sp);
    printf("스레드에서 shared_ptr 사용 중 - ref_count: %d\n", *(sp->ref_count));
 
    sleep(1);
 
    release_shared_ptr(sp);
    return NULL;
}
 
void* thread_function_unique(void* arg) {
    (void)arg; // Ignore the unused variable
    printf("스레드에서 unique_ptr 사용 중\n");
 
    sleep(1);
    return NULL;
}
 
#endif // KERNEL_UNIQUEPTR_H