cuckoogpu::FilterIPCClient< Config > Class Template Reference

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

Public Types
using	T = typename Config::KeyType

Public Member Functions
	FilterIPCClient (const std::string &name)
	Constructs a new FilterIPCClient.
	~FilterIPCClient ()
	Destroys the FilterIPCClient.
size_t	insertMany (const T *d_keys, size_t count)
	Inserts multiple keys into the filter.
void	containsMany (const T *d_keys, size_t count, bool *d_output)
	Checks for existence of multiple keys.
size_t	deleteMany (const T *d_keys, size_t count, bool *d_output=nullptr)
	Deletes multiple keys from the filter.
void	clear ()
	Clears the filter.
void	requestShutdown ()
	Requests the server to shut down.
size_t	insertMany (const thrust::device_vector< T > &d_keys)
	Inserts keys from a Thrust device vector.
void	containsMany (const thrust::device_vector< T > &d_keys, thrust::device_vector< bool > &d_output)
	Checks for existence of keys in a Thrust device vector.
void	containsMany (const thrust::device_vector< T > &d_keys, thrust::device_vector< uint8_t > &d_output)
	Checks for existence of keys in a Thrust device vector (uint8_t output).
size_t	deleteMany (const thrust::device_vector< T > &d_keys, thrust::device_vector< bool > &d_output)
	Deletes keys in a Thrust device vector.
size_t	deleteMany (const thrust::device_vector< T > &d_keys, thrust::device_vector< uint8_t > &d_output)
	Deletes keys in a Thrust device vector (uint8_t output).
size_t	deleteMany (const thrust::device_vector< T > &d_keys)
	Deletes keys in a Thrust device vector without outputting results.

Detailed Description

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

Client implementation for the IPC Cuckoo Filter.

This class connects to an existing shared memory segment created by a server and allows submitting filter operations. It handles the details of mapping memory handles for CUDA IPC.

Template Parameters

Config

The configuration structure for the Cuckoo Filter.

Definition at line 459 of file CuckooFilterIPC.cuh.

Member Typedef Documentation

T

template<typename Config >

using cuckoogpu::FilterIPCClient< Config >::T = typename Config::KeyType

Definition at line 467 of file CuckooFilterIPC.cuh.

Constructor & Destructor Documentation

FilterIPCClient()

template<typename Config >

cuckoogpu::FilterIPCClient< Config >::FilterIPCClient ( const std::string &  name )

inlineexplicit

Constructs a new FilterIPCClient.

Connects to the shared memory segment.

Parameters

name	Name of the shared memory segment to connect to.

Definition at line 476 of file CuckooFilterIPC.cuh.

        : shmName("/cuckoo_filter_" + name), nextRequestId(0) {
        shmFd = shm_open(shmName.c_str(), O_RDWR, 0666);
        if (shmFd == -1) {
            throw std::runtime_error("Failed to open shared memory, is the server running?");
        }
 
        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");
        }
 
        if (!queue->initialised.load(std::memory_order_acquire)) {
            munmap(queue, sizeof(SharedQueue));
            close(shmFd);
            throw std::runtime_error("Ring buffer not initialised, server may not be ready");
        }
    }

~FilterIPCClient()

template<typename Config >

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

inline

Destroys the FilterIPCClient.

Unmaps the shared memory.

Definition at line 504 of file CuckooFilterIPC.cuh.

                       {
        if (queue != MAP_FAILED) {
            munmap(queue, sizeof(SharedQueue));
        }
        if (shmFd != -1) {
            close(shmFd);
        }
    }

Member Function Documentation

clear()

template<typename Config >

void cuckoogpu::FilterIPCClient< Config >::clear ( )

inline

Clears the filter.

Definition at line 550 of file CuckooFilterIPC.cuh.

                 {
        submitRequest(RequestType::CLEAR, nullptr, 0, nullptr);
    }

containsMany() [1/3]

template<typename Config >

void cuckoogpu::FilterIPCClient< Config >::containsMany ( const T *  d_keys, size_t  count, bool *  d_output  )

inline

Checks for existence of multiple keys.

Parameters

d_keys	Pointer to device memory containing keys.
count	Number of keys to check.
d_output	Pointer to device memory to store results (true/false).

Definition at line 531 of file CuckooFilterIPC.cuh.

                                                                     {
        submitRequest(RequestType::CONTAINS, d_keys, count, d_output);
    }

Here is the caller graph for this function:

containsMany() [2/3]

template<typename Config >

void cuckoogpu::FilterIPCClient< Config >::containsMany ( const thrust::device_vector< T > &  d_keys, thrust::device_vector< bool > &  d_output  )

inline

Checks for existence of keys in a Thrust device vector.

Parameters

d_keys	Vector of keys to check.
d_output	Vector to store results (bool). Resized if necessary.

Definition at line 593 of file CuckooFilterIPC.cuh.

                                                                                            {
        if (d_output.size() != d_keys.size()) {
            d_output.resize(d_keys.size());
        }
        containsMany(
            thrust::raw_pointer_cast(d_keys.data()),
            d_keys.size(),
            thrust::raw_pointer_cast(d_output.data())
        );
    }

Here is the call graph for this function:

containsMany() [3/3]

template<typename Config >

void cuckoogpu::FilterIPCClient< Config >::containsMany ( const thrust::device_vector< T > &  d_keys, thrust::device_vector< uint8_t > &  d_output  )

inline

Checks for existence of keys in a Thrust device vector (uint8_t output).

Parameters

d_keys	Vector of keys to check.
d_output	Vector to store results (uint8_t). Resized if necessary.

Definition at line 610 of file CuckooFilterIPC.cuh.

                                                                                               {
        if (d_output.size() != d_keys.size()) {
            d_output.resize(d_keys.size());
        }
        containsMany(
            thrust::raw_pointer_cast(d_keys.data()),
            d_keys.size(),
            reinterpret_cast<bool*>(thrust::raw_pointer_cast(d_output.data()))
        );
    }

Here is the call graph for this function:

deleteMany() [1/4]

template<typename Config >

size_t cuckoogpu::FilterIPCClient< Config >::deleteMany ( const T *  d_keys, size_t  count, bool *  d_output = nullptr  )

inline

Deletes multiple keys from the filter.

Parameters

d_keys	Pointer to device memory containing keys.
count	Number of keys to delete.
d_output	Optional pointer to device memory to store results (true if deleted).

Returns

size_t Total number of occupied slots after deletion.

Definition at line 543 of file CuckooFilterIPC.cuh.

                                                                               {
        return submitRequest(RequestType::DELETE, d_keys, count, d_output);
    }

Here is the caller graph for this function:

deleteMany() [2/4]

template<typename Config >

size_t cuckoogpu::FilterIPCClient< Config >::deleteMany ( const thrust::device_vector< T > &  d_keys )

inline

Deletes keys in a Thrust device vector without outputting results.

Parameters

d_keys

Vector of keys to delete.

Returns

size_t Total number of occupied slots.

Definition at line 662 of file CuckooFilterIPC.cuh.

                                                            {
        return deleteMany(thrust::raw_pointer_cast(d_keys.data()), d_keys.size(), nullptr);
    }

Here is the call graph for this function:

deleteMany() [3/4]

template<typename Config >

size_t cuckoogpu::FilterIPCClient< Config >::deleteMany ( const thrust::device_vector< T > &  d_keys, thrust::device_vector< bool > &  d_output  )

inline

Deletes keys in a Thrust device vector.

Parameters

d_keys	Vector of keys to delete.
d_output	Vector to store results (bool). Resized if necessary.

Returns

size_t Total number of occupied slots.

Definition at line 628 of file CuckooFilterIPC.cuh.

                                                                                          {
        if (d_output.size() != d_keys.size()) {
            d_output.resize(d_keys.size());
        }
        return deleteMany(
            thrust::raw_pointer_cast(d_keys.data()),
            d_keys.size(),
            thrust::raw_pointer_cast(d_output.data())
        );
    }

Here is the call graph for this function:

deleteMany() [4/4]

template<typename Config >

size_t cuckoogpu::FilterIPCClient< Config >::deleteMany ( const thrust::device_vector< T > &  d_keys, thrust::device_vector< uint8_t > &  d_output  )

inline

Deletes keys in a Thrust device vector (uint8_t output).

Parameters

d_keys	Vector of keys to delete.
d_output	Vector to store results (uint8_t). Resized if necessary.

Returns

size_t Total number of occupied slots.

Definition at line 646 of file CuckooFilterIPC.cuh.

                                                                                             {
        if (d_output.size() != d_keys.size()) {
            d_output.resize(d_keys.size());
        }
        return deleteMany(
            thrust::raw_pointer_cast(d_keys.data()),
            d_keys.size(),
            reinterpret_cast<bool*>(thrust::raw_pointer_cast(d_output.data()))
        );
    }

Here is the call graph for this function:

insertMany() [1/2]

template<typename Config >

size_t cuckoogpu::FilterIPCClient< Config >::insertMany ( const T *  d_keys, size_t  count  )

inline

Inserts multiple keys into the filter.

Parameters

d_keys	Pointer to device memory containing keys.
count	Number of keys to insert.

Returns

size_t Total number of occupied slots after insertion.

Definition at line 520 of file CuckooFilterIPC.cuh.

                                                     {
        return submitRequest(RequestType::INSERT, d_keys, count, nullptr);
    }

Here is the caller graph for this function:

insertMany() [2/2]

template<typename Config >

size_t cuckoogpu::FilterIPCClient< Config >::insertMany ( const thrust::device_vector< T > &  d_keys )

inline

Inserts keys from a Thrust device vector.

Parameters

d_keys

Vector of keys to insert.

Returns

size_t Total number of occupied slots.

Definition at line 583 of file CuckooFilterIPC.cuh.

                                                            {
        return insertMany(thrust::raw_pointer_cast(d_keys.data()), d_keys.size());
    }

Here is the call graph for this function:

requestShutdown()

template<typename Config >

void cuckoogpu::FilterIPCClient< Config >::requestShutdown ( )

inline

Requests the server to shut down.

Definition at line 557 of file CuckooFilterIPC.cuh.

                           {
        if (queue->isShuttingDown()) {
            return;
        }
 
        queue->initiateShutdown();
 
        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();
 
            while (!req->completed.load(std::memory_order_acquire)) {
                std::this_thread::yield();
            }
        }
    }

Here is the call graph for this function:

---

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

• CuckooFilterIPC.cuh