cuckoogpu::FilterIPCServer< Config > Class Template Reference

Server implementation for the IPC Cuckoo Filter. More...

Public Member Functions
	FilterIPCServer (const std::string &name, size_t capacity)
	Constructs a new FilterIPCServer.
	~FilterIPCServer ()
	Destroys the FilterIPCServer.
void	start ()
	Starts the worker thread to process requests.
void	stop (bool force=false)
	Stops the server.
Filter< Config > *	getFilter ()
	Returns a pointer to the underlying Filter instance.

Detailed Description

template<typename Config>
class cuckoogpu::FilterIPCServer< Config >

Server implementation for the IPC Cuckoo Filter.

This class manages the shared memory segment and processes requests from clients. It runs a worker thread that polls the shared queue and executes filter operations on the GPU.

Template Parameters

Config

The configuration structure for the Cuckoo Filter.

Definition at line 193 of file CuckooFilterIPC.cuh.

Constructor & Destructor Documentation

FilterIPCServer()

template<typename Config >

cuckoogpu::FilterIPCServer< Config >::FilterIPCServer ( const std::string &  name, size_t  capacity  )

inline

Constructs a new FilterIPCServer.

Creates the shared memory segment and initializes the shared queue.

Parameters

name	Unique name for the shared memory segment.
capacity	Capacity of the Cuckoo Filter.

Definition at line 320 of file CuckooFilterIPC.cuh.

        : shmName("/cuckoo_filter_" + name), running(false) {
        filter = new Filter<Config>(capacity);
 
        // shared memory for queue
        shmFd = shm_open(shmName.c_str(), O_CREAT | O_RDWR, 0666);
        if (shmFd == -1) {
            throw std::runtime_error("Failed to create shared memory");
        }
 
        if (ftruncate(shmFd, sizeof(SharedQueue)) == -1) {
            close(shmFd);
            throw std::runtime_error("Failed to set shared memory size");
        }
 
        queue = static_cast<SharedQueue*>(
            mmap(nullptr, sizeof(SharedQueue), PROT_READ | PROT_WRITE, MAP_SHARED, shmFd, 0)
        );
 
        if (queue == MAP_FAILED) {
            close(shmFd);
            throw std::runtime_error("Failed to map shared memory");
        }
 
        queue->head.store(0, std::memory_order_release);
        queue->tail.store(0, std::memory_order_release);
        queue->shuttingDown.store(false, std::memory_order_release);
 
        sem_init(&queue->producerSem, 1, SharedQueue::QUEUE_SIZE);
        sem_init(&queue->consumerSem, 1, 0);
 
        for (auto& request : queue->requests) {
            request.completed.store(false, std::memory_order_release);
            request.cancelled.store(false, std::memory_order_release);
        }
 
        queue->initialised.store(true, std::memory_order_release);
    }

~FilterIPCServer()

template<typename Config >

cuckoogpu::FilterIPCServer< Config >::~FilterIPCServer ( )

inline

Destroys the FilterIPCServer.

Stops the server, cleans up shared memory and resources.

Definition at line 364 of file CuckooFilterIPC.cuh.

                       {
        stop();
 
        if (queue != MAP_FAILED) {
            sem_destroy(&queue->producerSem);
            sem_destroy(&queue->consumerSem);
            munmap(queue, sizeof(SharedQueue));
        }
 
        if (shmFd != -1) {
            close(shmFd);
            shm_unlink(shmName.c_str());
        }
 
        delete filter;
    }

Here is the call graph for this function:

Member Function Documentation

getFilter()

template<typename Config >

Filter< Config > * cuckoogpu::FilterIPCServer< Config >::getFilter ( )

inline

Returns a pointer to the underlying Filter instance.

Returns

Filter<Config>* Pointer to the filter.

Definition at line 444 of file CuckooFilterIPC.cuh.

                                {
        return filter;
    }

start()

template<typename Config >

void cuckoogpu::FilterIPCServer< Config >::start ( )

inline

Starts the worker thread to process requests.

Definition at line 384 of file CuckooFilterIPC.cuh.

                 {
        if (running) {
            return;
        }
 
        running = true;
        workerThread = std::thread(&FilterIPCServer::processRequests, this);
    }

stop()

template<typename Config >

void cuckoogpu::FilterIPCServer< Config >::stop ( bool  force = false )

inline

Stops the server.

Parameters

force

If true, cancels pending requests immediately. If false, waits for pending requests to complete.

Definition at line 399 of file CuckooFilterIPC.cuh.

                                  {
        if (!running) {
            return;
        }
 
        running = false;
 
        if (force) {
            size_t cancelled = queue->cancelPendingRequests();
            if (cancelled > 0) {
                std::cout << std::format(
                    "Force shutdown: cancelled {} pending requests\n", cancelled
                );
            }
        } else {
            size_t pending = queue->pendingRequests();
            if (pending > 0) {
                std::cout << std::format(
                    "Graceful shutdown: draining {} pending requests...\n", pending
                );
            }
        }
 
        // Send shutdown request to the worker thread before
        // setting shutdown flag so the enqueue() doesn't reject it
        FilterRequest* req = queue->enqueue();
        if (req) {
            req->type = RequestType::SHUTDOWN;
            req->completed.store(false, std::memory_order_release);
            req->cancelled.store(false, std::memory_order_release);
 
            queue->signalEnqueued();
        }
 
        queue->initiateShutdown();
 
        if (workerThread.joinable()) {
            workerThread.join();
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• CuckooFilterIPC.cuh