You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
105 lines
3.4 KiB
Plaintext
105 lines
3.4 KiB
Plaintext
/**
|
|
* @file
|
|
* @brief Serverside command structure for client-server interaction.
|
|
*
|
|
* @author Thomas Escher
|
|
*/
|
|
|
|
#ifndef SCANSERVER_SERVERINTERFACE_H
|
|
#define SCANSERVER_SERVERINTERFACE_H
|
|
|
|
#include "scanserver/clientInterface.h"
|
|
#include "scanserver/cache/cacheManager.h"
|
|
|
|
// hide the boost namespace
|
|
namespace
|
|
{
|
|
namespace ip = boost::interprocess;
|
|
// the segment manager providing the allocations
|
|
typedef ip::managed_shared_memory::segment_manager SegmentManager;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief Central instance of the server management.
|
|
*
|
|
* This class handles all the serverside communication and relays cache management calls to the CacheManager.
|
|
* It derives ClientInterface and shares its mutexes and arguments, neccessary for the communication. It also holds the SharedScan and CacheManager instances.
|
|
* create will open the shared memory and place a ServerInterface instance in it, after which the main server loop run handles all communication.
|
|
*/
|
|
class ServerInterface : public ClientInterface
|
|
{
|
|
private:
|
|
//! Container for all shared scans the server can hold
|
|
SharedScanVector m_scans;
|
|
|
|
//! Cache manager for handling all cache objects inside the shared scans
|
|
CacheManager m_manager;
|
|
|
|
//! Saved size of the CacheObject shared memory
|
|
std::size_t m_cache_size;
|
|
|
|
private:
|
|
//! Read a directory of scans by letting the corresponding ScanIO reading it and creating a scan for each entry
|
|
SharedScanVector* readDirectory(const char * dir_path, IOType type, unsigned int start, unsigned int end);
|
|
|
|
//! Cache miss from a CacheObject, relayed to CacheManager
|
|
bool loadCacheObject(CacheObject* obj);
|
|
|
|
//! Allocate call from SharedScan, relayed to CacheManager
|
|
void allocateCacheObject(CacheObject* obj, unsigned int size);
|
|
|
|
//! Invalidate call from SharedScan, relayed to CacheManager
|
|
void invalidateCacheObject(CacheObject* obj);
|
|
|
|
//! Call from SharedScan, relayed to ScanIO
|
|
void getPose(SharedScan* scan);
|
|
|
|
//! Allocate a new Frame in its vector
|
|
void addFrame(SharedScan* scan);
|
|
|
|
//! Relayed to FrameIO
|
|
void loadFramesFile(SharedScan* scan);
|
|
|
|
//! Relayed to FrameIO
|
|
void saveFramesFile(SharedScan* scan);
|
|
|
|
//! Empties this SharedScan's FrameVector
|
|
void clearFrames(SharedScan* scan);
|
|
|
|
//! Call from client
|
|
std::size_t getCacheSize();
|
|
|
|
//! Prints out caching related metrics
|
|
void printMetrics();
|
|
|
|
//! Find a scan by matching its identifier, path and io type to avoid placing the same scan multiple times into the scan vector
|
|
SharedScan* findScan(const SharedStringSharedPtr& dir_path, const char* identifier, IOType type) const;
|
|
|
|
public:
|
|
/**
|
|
* Constructor
|
|
* @param sm SegmentManager for allocator objects to construct interprocess containers with
|
|
* @param shm_name Name of the cache shared memory that will be passed to CacheManager
|
|
* @param cache_size Size of cache shared memory
|
|
*/
|
|
ServerInterface(SegmentManager* sm, const char* shm_name, std::size_t cache_size);
|
|
~ServerInterface();
|
|
|
|
//! Create the shared memory in the system and put all neccessary structures in it
|
|
static ServerInterface* create(std::size_t data_size, std::size_t cache_size);
|
|
|
|
//! remove the shared memory from the system
|
|
static void destroy();
|
|
|
|
//! Main server loop for message handling and function dispatching
|
|
void run();
|
|
|
|
private:
|
|
//! Cleaning up internal data without destroying the instance
|
|
void cleanup();
|
|
};
|
|
|
|
#endif //SCANSERVER_SERVERINTERFACE_H
|