3dpcp/.svn/pristine/80/804ad40bf20ded023f5c501d5ed1b552110b1df0.svn-base
2012-09-16 14:33:11 +02:00

303 lines
7.7 KiB
Text

/*
* clientinterface implementation
*
* Copyright (C) Thomas Escher, Kai Lingemann
*
* Released under the GPL version 3.
*
*/
#include "scanserver/clientInterface.h"
#include <iostream>
using std::cout;
using std::cerr;
using std::cin;
using std::endl;
#include <stdexcept>
#include <boost/filesystem.hpp>
using namespace boost::filesystem;
using namespace boost::interprocess;
#include "scanserver/defines.h"
#ifdef WITH_METRICS
#include "slam6d/metrics.h"
#endif
managed_shared_memory* ClientInterface::m_msm = 0;
ClientInterface* ClientInterface::m_singleton = 0;
SharedScanVector * ClientInterface::readDirectory(const char * dir_path, IOType type, unsigned int start, unsigned int end)
{
path to_add(dir_path);
if(!exists(to_add) || !is_directory(to_add)) {
// TODO: throw an exception
cerr << "Directory " << to_add << " does not exist" << endl;
return 0;
}
// aquire client mutex for uninterrupted work
scoped_lock<interprocess_mutex> lock(m_mutex_client);
// pass a system complete (absolute) path for compability with possibly
// different working directories in different processes
m_arg_string_1 = system_complete(to_add).string().c_str();
m_arg_io_type = type;
m_arg_uint_1 = start;
m_arg_uint_2 = end;
sendMessage(MESSAGE_READ_DIRECTORY);
// don't catch the exception, there is nothing this function can fix
SharedScanVector* scans = m_scanvector_ptr.get();
m_scanvector_ptr = 0;
return scans;
}
void ClientInterface::closeDirectory(SharedScanVector*& scans)
{
if(scans == 0) return;
// release all scans
// TODO: either lower recursive mutexes in all scans or notice the server
// delete scan vector
segment_manager->destroy_ptr(scans);
// set scans to 0 since it's a reference
scans = 0;
}
bool ClientInterface::loadCacheObject(CacheObject* obj)
{
// aquire client mutex for uninterrupted work
scoped_lock<interprocess_mutex> lock(m_mutex_client);
#ifdef WITH_METRICS
Timer t = ClientMetric::cache_miss_time.start();
#endif //WITH_METRICS
m_cacheobject_ptr = obj;
sendMessage(MESSAGE_LOAD_CACHE_OBJECT);
bool success = m_arg_uint_1 == 1;
m_arg_uint_1 = 0;
#ifdef WITH_METRICS
ClientMetric::cache_miss_time.end(t);
#endif //WITH_METRICS
return success;
}
void ClientInterface::allocateCacheObject(CacheObject* obj, unsigned int size)
{
// aquire client mutex for uninterrupted work
scoped_lock<interprocess_mutex> lock(m_mutex_client);
#ifdef WITH_METRICS
Timer t = ClientMetric::allocate_time.start();
#endif //WITH_METRICS
m_cacheobject_ptr = obj;
m_arg_uint_1 = size;
sendMessage(MESSAGE_ALLOCATE_CACHE_OBJECT);
#ifdef WITH_METRICS
ClientMetric::allocate_time.end(t);
#endif //WITH_METRICS
}
void ClientInterface::invalidateCacheObject(CacheObject* obj)
{
// aquire client mutex for uninterrupted work
scoped_lock<interprocess_mutex> lock(m_mutex_client);
m_cacheobject_ptr = obj;
sendMessage(MESSAGE_INVALIDATE_CACHE_OBJECT);
}
void ClientInterface::getPose(SharedScan* scan)
{
// aquire client mutex for uninterrupted work
scoped_lock<interprocess_mutex> lock(m_mutex_client);
m_sharedscan_ptr = scan;
sendMessage(MESSAGE_GET_POSE);
}
void ClientInterface::addFrame(SharedScan* scan, double* transformation, unsigned int type)
{
// aquire client mutex for uninterrupted work
scoped_lock<interprocess_mutex> lock(m_mutex_client);
#ifdef WITH_METRICS
Timer t = ClientMetric::frames_time.start();
#endif //WITH_METRICS
m_sharedscan_ptr = scan;
sendMessage(MESSAGE_ADD_FRAME);
// write into the new frame
const FrameVector& frames = scan->getFrames();
Frame& frame = const_cast<Frame&>(frames.back());
frame.set(transformation, type);
#ifdef WITH_METRICS
ClientMetric::frames_time.end(t);
#endif //WITH_METRICS
}
void ClientInterface::loadFramesFile(SharedScan* scan)
{
// aquire client mutex for uninterrupted work
scoped_lock<interprocess_mutex> lock(m_mutex_client);
#ifdef WITH_METRICS
Timer t = ClientMetric::frames_time.start();
#endif //WITH_METRICS
m_sharedscan_ptr = scan;
sendMessage(MESSAGE_LOAD_FRAMES_FILE);
#ifdef WITH_METRICS
ClientMetric::frames_time.end(t);
#endif //WITH_METRICS
}
void ClientInterface::saveFramesFile(SharedScan* scan)
{
// aquire client mutex for uninterrupted work
scoped_lock<interprocess_mutex> lock(m_mutex_client);
#ifdef WITH_METRICS
Timer t = ClientMetric::frames_time.start();
#endif //WITH_METRICS
m_sharedscan_ptr = scan;
sendMessage(MESSAGE_SAVE_FRAMES_FILE);
#ifdef WITH_METRICS
ClientMetric::frames_time.end(t);
#endif //WITH_METRICS
}
void ClientInterface::clearFrames(SharedScan* scan)
{
// aquire client mutex for uninterrupted work
scoped_lock<interprocess_mutex> lock(m_mutex_client);
#ifdef WITH_METRICS
Timer t = ClientMetric::frames_time.start();
#endif //WITH_METRICS
m_sharedscan_ptr = scan;
sendMessage(MESSAGE_CLEAR_FRAMES);
// TODO: remove the .frames-file if appropriate, clear all records
#ifdef WITH_METRICS
ClientMetric::frames_time.end(t);
#endif //WITH_METRICS
}
std::size_t ClientInterface::getCacheSize()
{
// aquire client mutex for uninterrupted work
scoped_lock<interprocess_mutex> lock(m_mutex_client);
sendMessage(MESSAGE_GET_CACHE_SIZE);
return m_arg_size_t;
}
void ClientInterface::printMetrics()
{
// aquire client mutex for uninterrupted work
scoped_lock<interprocess_mutex> lock(m_mutex_client);
sendMessage(MESSAGE_PRINT_METRICS);
}
void ClientInterface::sendMessage(message_t message)
{
#ifdef WITH_METRICS
Timer t = ClientMetric::clientinterface_time.start();
#endif //WITH_METRICS
// try to lock the server mutex to send when it's not occupied
scoped_lock<interprocess_mutex> lock(m_mutex_server);
// set message
m_message = message;
// notify and wake up the server and wait until the message is processed
m_condition_server.notify_one();
m_condition_client.wait(lock);
#ifdef WITH_METRICS
ClientMetric::clientinterface_time.end(t);
#endif //WITH_METRICS
// process errors
// TODO: better
if(!m_error_message.empty()) {
std::string msg(m_error_message.c_str());
m_error_message.clear();
throw std::runtime_error(msg);
}
}
ClientInterface* ClientInterface::create()
{
// open the shared memory in this application
if(m_msm == 0) {
try {
m_msm = new managed_shared_memory(open_only, SHM_NAME_DATA);
} catch(interprocess_exception& e) {
throw std::runtime_error(std::string("Could not open shared memory: ") + e.what());
}
}
// now try to open the cache shared memory
CacheObject::openSharedMemory(SHM_NAME_CACHE);
// prepare singleton pointer
offset_ptr<ClientInterface>* ptr = m_msm->find<offset_ptr<ClientInterface> >(unique_instance).first;
if(ptr == 0)
throw std::runtime_error("Could not find the ClientInterface pointer in shared memory");
m_singleton = ptr->get();
// test for old crashed clients
{
scoped_lock<interprocess_mutex> lock(m_singleton->m_mutex_client, try_to_lock);
if(!lock) {
cout << "Scanserver communication is currently blocked, waiting for server... " << std::flush;
// wait for server to finish, lock and immediately unlock the server mutex
{scoped_lock<interprocess_mutex> lock_server(m_singleton->m_mutex_server);}
// clean up the client mutex which was left locked by previous program calls
m_singleton->m_mutex_client.unlock();
cout << "done." /* Stop crashing/interrupting programs */ << endl;
}
}
return m_singleton;
}
void ClientInterface::destroy()
{
m_singleton = 0;
if(m_msm != 0) {
delete m_msm;
m_msm = 0;
}
}
ClientInterface* ClientInterface::getInstance()
{
if(m_singleton == 0)
throw std::runtime_error("ClientInterface Singleton not set");
return m_singleton;
}