Skip to content

U
uniset2
Commit afa40939 authored by Pavel Vainerman's avatar Pavel Vainerman
Browse files
Options

(Mutex): ПЕРЕХОД НА RWMUTEX-Ы ВЕЗДЕ ГДЕ МОЖНО

parent 3b35d826
Hide whitespace changes
Inline Side-by-side
Showing with 603 additions and 463 deletions
conf/test.xml
View file @ afa40939
......@@ -121,7 +121,7 @@
<UNetExchange name="UNetExchange"/>
<HeartBeatTime time_msec="5000"/>
<TestGen input1_s="Input1_S" input2_s="DumpSensor1_S" name="TestGen" output1_c="DO_C"/>
<RRDStorage1 name="RRDStorage1">
<RRDServer1 name="RRDServer1">
<rrd filename="rrdtest.rrd" filter_field="rrd" filter_value="1" step="5" ds_field="rrd1_ds" overwrite="0">
<item rra="RRA:AVERAGE:0.5:1:4320"/>
<item rra="RRA:MAX:0.5:1:4320"/>
......@@ -130,7 +130,7 @@
<item rra="RRA:AVERAGE:0.5:1:4320"/>
<item rra="RRA:MAX:0.5:1:4320"/>
</rrd>
</RRDStorage1>
</RRDServer1>
</settings>
<ObjectsMap idfromfile="0">
<!--
......@@ -243,7 +243,7 @@
<item id="6008" name="UNetExchange"/>
<item id="6009" name="MBMaster2"/>
<item id="6010" name="MBMultiMaster1"/>
<item id="6011" name="RRDStorage1"/>
<item id="6011" name="RRDServer1"/>
</objects>
</ObjectsMap>
<messages idfromfile="1" name="messages">
......
extensions/DBServer-MySQL/DBServer_MySQL.cc
View file @ afa40939
......@@ -53,6 +53,8 @@ DBServer_MySQL::DBServer_MySQL(ObjectId id):
msg << "(DBServer_MySQL): init failed! Unknown ID!" << endl;
throw Exception(msg.str());
}
mqbuf.setName(myname + "_qbufMutex");
}
DBServer_MySQL::DBServer_MySQL():
......@@ -72,6 +74,8 @@ DBServer_MySQL::DBServer_MySQL():
msg << "(DBServer_MySQL): init failed! Unknown ID!" << endl;
throw Exception(msg.str());
}
mqbuf.setName(myname + "_qbufMutex");
}
//--------------------------------------------------------------------------------------------
DBServer_MySQL::~DBServer_MySQL()
......@@ -206,7 +210,7 @@ bool DBServer_MySQL::writeToBase( const string& query )
// cout << "DBServer_MySQL: " << query << endl;
if( !db || !connect_ok )
{
uniset_mutex_lock l(mqbuf,200);
uniset_rwmutex_wrlock l(mqbuf);
qbuf.push(query);
if( qbuf.size() > qbufSize )
{
......@@ -247,7 +251,7 @@ bool DBServer_MySQL::writeToBase( const string& query )
//--------------------------------------------------------------------------------------------
void DBServer_MySQL::flushBuffer()
{
uniset_mutex_lock l(mqbuf,400);
uniset_rwmutex_wrlock l(mqbuf);
// Сперва пробуем очистить всё что накопилось в очереди до этого...
while( !qbuf.empty() )
......
extensions/DBServer-MySQL/DBServer_MySQL.h
View file @ afa40939
......@@ -187,7 +187,7 @@ class DBServer_MySQL:
bool lastRemove;
void flushBuffer();
UniSetTypes::uniset_mutex mqbuf;
UniSetTypes::uniset_rwmutex mqbuf;
private:
DBTableMap tblMap;
......
extensions/DBServer-SQLite/DBServer_SQLite.cc
View file @ afa40939
......@@ -203,7 +203,7 @@ bool DBServer_SQLite::writeToBase( const string& query )
// cout << "DBServer_SQLite: " << query << endl;
if( !db || !connect_ok )
{
uniset_mutex_lock l(mqbuf,200);
uniset_rwmutex_wrlock l(mqbuf);
qbuf.push(query);
if( qbuf.size() > qbufSize )
{
......@@ -234,7 +234,7 @@ bool DBServer_SQLite::writeToBase( const string& query )
//--------------------------------------------------------------------------------------------
void DBServer_SQLite::flushBuffer()
{
uniset_mutex_lock l(mqbuf,400);
uniset_rwmutex_wrlock l(mqbuf);
// Сперва пробуем очистить всё что накопилось в очереди до этого...
while( !qbuf.empty() )
......
extensions/DBServer-SQLite/DBServer_SQLite.h
View file @ afa40939
......@@ -187,7 +187,7 @@ class DBServer_SQLite:
bool lastRemove;
void flushBuffer();
UniSetTypes::uniset_mutex mqbuf;
UniSetTypes::uniset_rwmutex mqbuf;
private:
DBTableMap tblMap;
......
extensions/IOControl/IOControl.cc
View file @ afa40939
......@@ -557,7 +557,7 @@ void IOControl::ioread( IOInfo* it )
}
else // управление лампочками
{
uniset_spin_lock lock(it->val_lock);
uniset_rwmutex_wrlock lock(it->val_lock);
long prev_val = it->value;
if( force_out )
it->value = shm->localGetValue(it->ait,it->si.id);
......@@ -1425,7 +1425,7 @@ void IOControl::sensorInfo( UniSetTypes::SensorMessage* sm )
long prev_val = 0;
long cur_val = 0;
{
uniset_spin_lock lock(it->val_lock);
uniset_rwmutex_wrlock lock(it->val_lock);
prev_val = it->value;
it->value = sm->value;
cur_val = sm->value;
......@@ -1520,7 +1520,7 @@ void IOControl::sensorInfo( UniSetTypes::SensorMessage* sm )
dlog[Debug::LEVEL1] << myname << "(sensorInfo): DO: sm->id=" << sm->id
<< " val=" << sm->value << endl;
}
uniset_spin_lock lock(it->val_lock);
uniset_rwmutex_wrlock lock(it->val_lock);
it->value = sm->state ? 1:0;
}
break;
......
extensions/ModbusMaster/MBExchange.cc
View file @ afa40939
......@@ -36,6 +36,8 @@ pollActivated(false)
if( objId == DefaultObjectId )
throw UniSetTypes::SystemError("(MBExchange): objId=-1?!! Use --" + prefix + "-name" );
mutex_start.setName(myname + "_mutex_start");
// xmlNode* cnode = conf->getNode(myname);
string conf_name = conf->getArgParam("--" + prefix + "-confnode",myname);
......@@ -225,13 +227,13 @@ void MBExchange::step()
// -----------------------------------------------------------------------------
bool MBExchange::checkProcActive()
{
uniset_mutex_lock l(actMutex, 300);
uniset_rwmutex_rlock l(actMutex);
return activated;
}
// -----------------------------------------------------------------------------
void MBExchange::setProcActive( bool st )
{
uniset_mutex_lock l(actMutex, 400);
uniset_rwmutex_wrlock l(actMutex);
activated = st;
}
// -----------------------------------------------------------------------------
......@@ -2417,7 +2419,7 @@ bool MBExchange::activateObject()
// см. sysCommand()
{
setProcActive(false);
UniSetTypes::uniset_mutex_lock l(mutex_start, 5000);
UniSetTypes::uniset_rwmutex_rlock l(mutex_start);
UniSetObject_LT::activateObject();
if( !shm->isLocalwork() )
rtuQueryOptimization(rmap);
......@@ -2511,7 +2513,7 @@ void MBExchange::sysCommand( UniSetTypes::SystemMessage *sm )
dlog[Debug::CRIT] << myname << "(sysCommand): ************* don`t activate?! ************" << endl;
{
UniSetTypes::uniset_mutex_lock l(mutex_start, 10000);
UniSetTypes::uniset_rwmutex_rlock l(mutex_start);
askSensors(UniversalIO::UIONotify);
initOutput();
}
......
extensions/ModbusMaster/MBExchange.h
View file @ afa40939
......@@ -281,7 +281,7 @@ class MBExchange:
SMInterface* shm;
bool initPause;
UniSetTypes::uniset_mutex mutex_start;
UniSetTypes::uniset_rwmutex mutex_start;
bool force; /*!< флаг означающий, что надо сохранять в SM, даже если значение не менялось */
bool force_out; /*!< флаг означающий, принудительного чтения выходов */
......@@ -299,7 +299,7 @@ class MBExchange:
IOController::AIOStateList::iterator aitExchangeMode;
long exchangeMode; /*!< режим работы см. ExchangeMode */
UniSetTypes::uniset_mutex actMutex;
UniSetTypes::uniset_rwmutex actMutex;
bool activated;
int activateTimeout;
bool noQueryOptimization;
......
extensions/ModbusMaster/MBTCPMaster.h
View file @ afa40939
......@@ -207,7 +207,7 @@ class MBTCPMaster:
protected:
virtual void sysCommand( UniSetTypes::SystemMessage *sm );
UniSetTypes::uniset_mutex mbMutex;
UniSetTypes::uniset_rwmutex mbMutex;
std::string iaddr;
// ost::InetAddress* ia;
int port;
......@@ -227,7 +227,7 @@ class MBTCPMaster:
// т.к. TCP может "зависнуть" на подключении к недоступному узлу
// делаем опрос в отдельном потоке
ThreadCreator<MBTCPMaster>* pollThread; /*!< поток опроса */
UniSetTypes::uniset_mutex tcpMutex;
UniSetTypes::uniset_rwmutex tcpMutex;
};
// -----------------------------------------------------------------------------
#endif // _MBTCPMaster_H_
......
extensions/ModbusMaster/MBTCPMultiMaster.cc
View file @ afa40939
......@@ -17,6 +17,8 @@ force_disconnect(true),
pollThread(0),
checkThread(0)
{
tcpMutex.setName(myname+"_tcpMutex");
if( objId == DefaultObjectId )
throw UniSetTypes::SystemError("(MBTCPMultiMaster): objId=-1?!! Use --" + prefix + "-name" );
......@@ -179,7 +181,7 @@ ModbusClient* MBTCPMultiMaster::initMB( bool reopen )
}
{
uniset_mutex_lock l(tcpMutex,100);
uniset_rwmutex_wrlock l(tcpMutex);
// Если по текущему каналу связь есть, то возвращаем его
if( mbi!=mblist.rend() && mbi->respond )
{
......@@ -197,7 +199,7 @@ ModbusClient* MBTCPMultiMaster::initMB( bool reopen )
// проходим по списку (в обратном порядке, т.к. самый приоритетный в конце)
for( MBGateList::reverse_iterator it=mblist.rbegin(); it!=mblist.rend(); ++it )
{
uniset_mutex_lock l(tcpMutex,100);
uniset_rwmutex_wrlock l(tcpMutex);
if( it->respond && it->init() )
{
mbi = it;
......@@ -207,7 +209,7 @@ ModbusClient* MBTCPMultiMaster::initMB( bool reopen )
}
{
uniset_mutex_lock l(tcpMutex,100);
uniset_rwmutex_wrlock l(tcpMutex);
mbi = mblist.rend();
mb = 0;
}
......@@ -329,8 +331,8 @@ void MBTCPMultiMaster::check_thread()
catch(...){}
{
uniset_mutex_lock l(tcpMutex,130);
{
uniset_rwmutex_wrlock l(tcpMutex);
it->respond = r;
}
}
......
extensions/ModbusMaster/MBTCPMultiMaster.h
View file @ afa40939
......@@ -233,7 +233,7 @@ class MBTCPMultiMaster:
void poll_thread();
void check_thread();
UniSetTypes::uniset_mutex mbMutex;
UniSetTypes::uniset_rwmutex mbMutex;
int recv_timeout;
bool force_disconnect;
int checktime;
......@@ -285,7 +285,7 @@ class MBTCPMultiMaster:
// т.к. TCP может "зависнуть" на подключении к недоступному узлу
// делаем опрос в отдельном потоке
ThreadCreator<MBTCPMultiMaster>* pollThread; /*!< поток опроса */
UniSetTypes::uniset_mutex tcpMutex;
UniSetTypes::uniset_rwmutex tcpMutex;
ThreadCreator<MBTCPMultiMaster>* checkThread; /*!< поток проверки связи по другим каналам */
};
......
extensions/ModbusSlave/MBSlave.cc
View file @ afa40939
......@@ -32,6 +32,8 @@ prefix(prefix)
if( objId == DefaultObjectId )
throw UniSetTypes::SystemError("(MBSlave): objId=-1?!! Use --mbs-name" );
mutex_start.setName(myname + "_mutex_start");
// xmlNode* cnode = conf->getNode(myname);
cnode = conf->getNode(myname);
if( cnode == NULL )
......@@ -608,7 +610,7 @@ void MBSlave::sysCommand(UniSetTypes::SystemMessage *sm)
dlog[Debug::CRIT] << myname << "(sysCommand): ************* don`t activate?! ************" << endl;
else
{
UniSetTypes::uniset_mutex_lock l(mutex_start, 10000);
UniSetTypes::uniset_rwmutex_rlock l(mutex_start);
askSensors(UniversalIO::UIONotify);
thr->start();
}
......@@ -709,13 +711,13 @@ void MBSlave::sensorInfo( UniSetTypes::SensorMessage* sm )
if( p->stype == UniversalIO::DigitalOutput ||
p->stype == UniversalIO::DigitalInput )
{
uniset_spin_lock lock(p->val_lock);
uniset_rwmutex_wrlock lock(p->val_lock);
p->value = sm->state ? 1 : 0;
}
else if( p->stype == UniversalIO::AnalogOutput ||
p->stype == UniversalIO::AnalogInput )
{
uniset_spin_lock lock(p->val_lock);
uniset_rwmutex_wrlock lock(p->val_lock);
p->value = sm->value;
}
......@@ -754,7 +756,7 @@ bool MBSlave::activateObject()
// см. sysCommand()
{
activated = false;
UniSetTypes::uniset_mutex_lock l(mutex_start, 5000);
UniSetTypes::uniset_rwmutex_wrlock l(mutex_start);
UniSetObject_LT::activateObject();
initIterators();
activated = true;
......
extensions/ModbusSlave/MBSlave.h
View file @ afa40939
......@@ -130,7 +130,7 @@ class MBSlave:
ModbusServerSlot* mbslot;
ModbusRTU::ModbusAddr addr; /*!< адрес данного узла */
UniSetTypes::uniset_mutex mbMutex;
UniSetTypes::uniset_rwmutex mbMutex;
xmlNode* cnode;
std::string s_field;
......@@ -168,7 +168,7 @@ class MBSlave:
private:
MBSlave();
bool initPause;
UniSetTypes::uniset_mutex mutex_start;
UniSetTypes::uniset_rwmutex mutex_start;
ThreadCreator<MBSlave>* thr;
PassiveTimer ptHeartBeat;
......
extensions/ModbusSlave/start_tcp_fg.sh
View file @ afa40939
#!/bin/sh
uniset-start.sh -f ./uniset-mbslave --confile test.xml --dlog-add-levels info,crit,warn \
--smemory-id SharedMemory \
--mbs-name MBSlave1 \
--mbs-type TCP --mbs-inet-addr 127.0.0.1 --mbs-inet-port 2048 --mbs-reg-from-id 1 --mbs-my-addr 0x01 \
--mbs-askcount-id SVU_AskCount_AS --mbs-respond-id RespondRTU_S --mbs-respond-invert 1
......
extensions/RRDServer/Makefile.am
View file @ afa40939
......@@ -6,8 +6,8 @@ bin_PROGRAMS = @PACKAGE@-rrdserver
RRD_VER=@LIBVER@
lib_LTLIBRARIES = libUniSetRRDServer.la
libUniSetRRDServer_la_LDFLAGS = -version-info $(RRD_VER)
lib_LTLIBRARIES = libUniSetRRDServer.la
libUniSetRRDServer_la_LDFLAGS = -version-info $(RRD_VER)
libUniSetRRDServer_la_LIBADD = $(top_builddir)/lib/libUniSet.la \
$(top_builddir)/extensions/SharedMemory/libUniSetSharedMemory.la \
$(top_builddir)/extensions/lib/libUniSetExtensions.la \
......
extensions/RRDServer/start_fg.sh
View file @ afa40939
#!/bin/sh
uniset-start.sh -f ./uniset-rrdstorage --confile test.xml \
--rrd-name RRDStorage1 \
uniset-start.sh -f ./uniset-rrdserver --confile test.xml \
--rrd-name RRDServer1 \
--dlog-add-levels info,crit,warn
extensions/SharedMemory/SharedMemory.cc
View file @ afa40939
......@@ -23,7 +23,7 @@ void SharedMemory::help_print( int argc, const char* const* argv )
cout << "--wdt-device - Использовать в качестве WDT указанный файл." << endl;
cout << "--heartbeat-node - Загружать heartbeat датчики для указанного узла." << endl;
cout << "--heartbeat-check-time - период проверки 'счётчиков'. По умолчанию 1000 мсек" << endl;
cout << "--lock-value-pause - пауза между проверкой spin-блокировки на значение" << endl;
cout << "--lock-rvalue-pause-msec - пауза между проверкой rw-блокировки на разрешение чтения" << endl;
cout << "--e-filter - фильтр для считывания <eventlist>" << endl;
cout << "--e-startup-pause - пауза перед посылкой уведомления о старте SM. (По умолчанию: 1500 мсек)." << endl;
cout << "--activate-timeout - время ожидания активизации (По умолчанию: 15000 мсек)." << endl;
......@@ -44,6 +44,9 @@ SharedMemory::SharedMemory( ObjectId id, string datafile, std::string confname )
iotypePulsar(UniversalIO::DigitalInput),
msecPulsar(0)
{
mutex_start.setName(myname + "_mutex_start");
mutex_act.setName(myname + "_mutex_act");
string cname(confname);
if( cname.empty() )
cname = ORepHelpers::getShortName(conf->oind->getMapName(id));
......@@ -70,7 +73,7 @@ SharedMemory::SharedMemory( ObjectId id, string datafile, std::string confname )
string t_field = conf->getArgParam("--t-filter-field");
string t_fvalue = conf->getArgParam("--t-filter-value");
int lock_msec = conf->getArgPInt("--lock-value-pause",0);
int lock_msec = conf->getArgPInt("--lock-rvalue-pause-msec",5);
if( lock_msec < 0 )
lock_msec = 0;
setCheckLockValuePause(lock_msec);
......@@ -269,7 +272,7 @@ void SharedMemory::sysCommand( SystemMessage *sm )
// подождать пока пройдёт инициализация
// см. activateObject()
UniSetTypes::uniset_mutex_lock l(mutex_start, 10000);
UniSetTypes::uniset_rwmutex_rlock l(mutex_start);
askTimer(tmHeartBeatCheck,heartbeatCheckTime);
askTimer(tmEvent,evntPause,1);
......@@ -328,11 +331,11 @@ bool SharedMemory::activateObject()
// см. sysCommand()
{
{
uniset_mutex_lock l(act_mutex,100);
uniset_rwmutex_wrlock l(mutex_act);
activated = false;
}
UniSetTypes::uniset_mutex_lock l(mutex_start, 5000);
UniSetTypes::uniset_rwmutex_wrlock l(mutex_start);
res = IONotifyController_LT::activateObject();
// инициализируем указатели
......@@ -356,7 +359,7 @@ bool SharedMemory::activateObject()
}
{
uniset_mutex_lock l(act_mutex,100);
uniset_rwmutex_wrlock l(mutex_act);
activated = true;
}
}
......@@ -864,7 +867,7 @@ std::ostream& operator<<( std::ostream& os, const SharedMemory::HistoryInfo& h )
// ------------------------------------------------------------------------------------------
bool SharedMemory::isActivated()
{
uniset_mutex_lock l(act_mutex,300);
uniset_rwmutex_rlock l(mutex_act);
return activated;
}
// ------------------------------------------------------------------------------------------
extensions/SharedMemory/SharedMemory.h
View file @ afa40939
......@@ -350,7 +350,7 @@ class SharedMemory:
void buildEventList( xmlNode* cnode );
void readEventList( std::string oname );
UniSetTypes::uniset_mutex mutex_start;
UniSetTypes::uniset_rwmutex mutex_start;
struct HeartBeatInfo
{
......@@ -422,8 +422,8 @@ class SharedMemory:
IOController_i::SensorInfo siPulsar;
UniversalIO::IOTypes iotypePulsar;
int msecPulsar;
UniSetTypes::uniset_mutex act_mutex;
UniSetTypes::uniset_rwmutex mutex_act;
private:
HistorySlot m_historySignal;
......
extensions/UNetUDP/UNetExchange.cc
View file @ afa40939
......@@ -532,7 +532,7 @@ void UNetExchange::sysCommand( UniSetTypes::SystemMessage *sm )
dlog[Debug::CRIT] << myname << "(sysCommand): ************* don`t activate?! ************" << endl;
{
UniSetTypes::uniset_mutex_lock l(mutex_start, 10000);
UniSetTypes::uniset_rwmutex_rlock l(mutex_start);
if( shm->isLocalwork() )
askSensors(UniversalIO::UIONotify);
}
......@@ -625,7 +625,7 @@ bool UNetExchange::activateObject()
// см. sysCommand()
{
activated = false;
UniSetTypes::uniset_mutex_lock l(mutex_start, 5000);
UniSetTypes::uniset_rwmutex_wrlock l(mutex_start);
UniSetObject_LT::activateObject();
initIterators();
activated = true;
......
extensions/UNetUDP/UNetExchange.h
View file @ afa40939
......@@ -125,7 +125,7 @@ class UNetExchange:
private:
UNetExchange();
bool initPause;
UniSetTypes::uniset_mutex mutex_start;
UniSetTypes::uniset_rwmutex mutex_start;
PassiveTimer ptHeartBeat;
UniSetTypes::ObjectId sidHeartBeat;
......
extensions/UNetUDP/UNetReceiver.cc
View file @ afa40939
......@@ -91,6 +91,7 @@ UNetReceiver::~UNetReceiver()
// -----------------------------------------------------------------------------
void UNetReceiver::setReceiveTimeout( timeout_t msec )
{
uniset_rwmutex_wrlock l(tmMutex);
recvTimeout = msec;
ptRecvTimeout.setTiming(msec);
}
......@@ -141,18 +142,18 @@ void UNetReceiver::setLostPacketsID( UniSetTypes::ObjectId id )
}
// -----------------------------------------------------------------------------
void UNetReceiver::setLockUpdate( bool st )
{
uniset_mutex_lock l(lockMutex,200);
lockUpdate = st;
{
uniset_rwmutex_wrlock l(lockMutex);
lockUpdate = st;
if( !st )
ptPrepare.reset();
}
// -----------------------------------------------------------------------------
void UNetReceiver::resetTimeout()
{
uniset_mutex_lock l(tmMutex,200);
ptRecvTimeout.reset();
trTimeout.change(false);
{
uniset_rwmutex_wrlock l(tmMutex);
ptRecvTimeout.reset();
trTimeout.change(false);
}
// -----------------------------------------------------------------------------
void UNetReceiver::start()
......@@ -223,7 +224,7 @@ void UNetReceiver::real_update()
while( k>0 )
{
{ // lock qpack
uniset_mutex_lock l(packMutex);
uniset_rwmutex_wrlock l(packMutex);
if( qpack.empty() )
return;
......@@ -293,7 +294,7 @@ void UNetReceiver::real_update()
// обновление данных в SM (блокировано)
{
uniset_mutex_lock l(lockMutex,100);
uniset_rwmutex_rlock l(lockMutex);
if( lockUpdate )
continue;
}
......@@ -336,7 +337,7 @@ void UNetReceiver::real_update()
// обновление данных в SM (блокировано)
{
uniset_mutex_lock l(lockMutex,100);
uniset_rwmutex_rlock l(lockMutex);
if( lockUpdate )
continue;
}
......@@ -375,8 +376,14 @@ void UNetReceiver::stop()
// -----------------------------------------------------------------------------
void UNetReceiver::receive()
{
dlog[Debug::INFO] << myname << ": ******************* receive start" << endl;
ptRecvTimeout.setTiming(recvTimeout);
if( dlog.debugging(Debug::INFO) )
dlog[Debug::INFO] << myname << ": ******************* receive start" << endl;
{
uniset_rwmutex_wrlock l(tmMutex);
ptRecvTimeout.setTiming(recvTimeout);
}
bool tout = false;
while( activated )
{
......@@ -384,27 +391,30 @@ void UNetReceiver::receive()
{
if( recv() )
{
uniset_mutex_lock l(tmMutex,100);
uniset_rwmutex_wrlock l(tmMutex);
ptRecvTimeout.reset();
}
}
catch( UniSetTypes::Exception& ex)
{
dlog[Debug::WARN] << myname << "(receive): " << ex << std::endl;
if( dlog.debugging(Debug::WARN) )
dlog[Debug::WARN] << myname << "(receive): " << ex << std::endl;
}
catch( std::exception& e )
{
dlog[Debug::WARN] << myname << "(receive): " << e.what()<< std::endl;
if( dlog.debugging(Debug::WARN) )
dlog[Debug::WARN] << myname << "(receive): " << e.what()<< std::endl;
}
catch(...)
{
dlog[Debug::WARN] << myname << "(receive): catch ..." << std::endl;
}
if( dlog.debugging(Debug::WARN) )
dlog[Debug::WARN] << myname << "(receive): catch ..." << std::endl;
}
// делаем через промежуточную переменную
// чтобы поскорее освободить mutex
{
uniset_mutex_lock l(tmMutex,100);
uniset_rwmutex_rlock l(tmMutex);
tout = ptRecvTimeout.checkTime();
}
......@@ -420,7 +430,8 @@ void UNetReceiver::receive()
msleep(recvpause);
}
dlog[Debug::INFO] << myname << ": ************* receive FINISH **********" << endl;
if( dlog.debugging(Debug::INFO) )
dlog[Debug::INFO] << myname << ": ************* receive FINISH **********" << endl;
}
// -----------------------------------------------------------------------------
bool UNetReceiver::recv()
......@@ -471,7 +482,7 @@ bool UNetReceiver::recv()
#endif
{ // lock qpack
uniset_mutex_lock l(packMutex,2000);
uniset_rwmutex_wrlock l(packMutex);
if( !waitClean )
{
qpack.push(pack);
......
extensions/UNetUDP/UNetReceiver.h
View file @ afa40939
......@@ -115,7 +115,7 @@ class UNetReceiver
ost::tpport_t port;
std::string myname;
UniSetTypes::uniset_mutex pollMutex;
UniSetTypes::uniset_rwmutex pollMutex;
PassiveTimer ptRecvTimeout;
PassiveTimer ptPrepare;
timeout_t recvTimeout;
......@@ -147,7 +147,7 @@ class UNetReceiver
PacketQueue qpack; /*!< очередь принятых пакетов (отсортированных по возрастанию номера пакета) */
UniSetUDP::UDPMessage pack; /*!< просто буфер для получения очередного сообщения */
UniSetUDP::UDPPacket r_buf;
UniSetTypes::uniset_mutex packMutex; /*!< mutex для работы с очередью */
UniSetTypes::uniset_rwmutex packMutex; /*!< mutex для работы с очередью */
unsigned long pnum; /*!< текущий номер обработанного сообщения, для проверки непрерывности последовательности пакетов */
/*! максимальная разница межд номерами пакетов, при которой считается, что счётчик пакетов
......@@ -162,11 +162,11 @@ class UNetReceiver
int maxProcessingCount; /*!< максимальное число обрабатываемых за один раз сообщений */
bool lockUpdate; /*!< флаг блокировки сохранения принятых данных в SM */
UniSetTypes::uniset_mutex lockMutex;
UniSetTypes::uniset_rwmutex lockMutex;
EventSlot slEvent;
Trigger trTimeout;
UniSetTypes::uniset_mutex tmMutex;
UniSetTypes::uniset_rwmutex tmMutex;
struct ItemInfo
{
......
extensions/UNetUDP/UNetSender.cc
View file @ afa40939
......@@ -128,12 +128,12 @@ void UNetSender::updateItem( DMap::iterator& it, long value )
if( it->iotype == UniversalIO::DigitalInput || it->iotype == UniversalIO::DigitalOutput )
{
UniSetTypes::uniset_mutex_lock l(pack_mutex,100);
UniSetTypes::uniset_rwmutex_wrlock l(pack_mutex);
mypack.setDData(it->pack_ind,value);
}
else if( it->iotype == UniversalIO::AnalogInput || it->iotype == UniversalIO::AnalogOutput )
{
UniSetTypes::uniset_mutex_lock l(pack_mutex,100);
UniSetTypes::uniset_rwmutex_wrlock l(pack_mutex);
mypack.setAData(it->pack_ind,value);
}
}
......@@ -190,7 +190,7 @@ void UNetSender::send()
// -----------------------------------------------------------------------------
void UNetSender::real_send()
{
UniSetTypes::uniset_mutex_lock l(pack_mutex,300);
UniSetTypes::uniset_rwmutex_rlock l(pack_mutex);
mypack.num = packetnum++;
if( packetnum > UniSetUDP::MaxPacketNum )
......@@ -199,7 +199,6 @@ void UNetSender::real_send()
if( !udp->isPending(ost::Socket::pendingOutput) )
return;
mypack.transport_msg(s_msg);
size_t ret = udp->send( (char*)s_msg.data, s_msg.len );
if( ret < s_msg.len )
......
extensions/UNetUDP/UNetSender.h
View file @ afa40939
......@@ -88,8 +88,8 @@ class UNetSender
std::string myname;
int sendpause;
bool activated;
UniSetTypes::uniset_mutex pack_mutex;
UniSetTypes::uniset_rwmutex pack_mutex;
UniSetUDP::UDPMessage mypack;
DMap dlist;
int maxItem;
......
extensions/UniNetwork/UniExchange.cc
View file @ afa40939
......@@ -257,7 +257,7 @@ IOController_i::ShortMapSeq* UniExchange::getSensors()
{
IOController_i::ShortMap m;
{
uniset_spin_lock lock(it->val_lock,30);
uniset_rwmutex_rlock lock(it->val_lock);
m.id = it->id;
m.value = it->val;
m.type = it->type;
......@@ -274,7 +274,7 @@ void UniExchange::updateLocalData()
{
try
{
uniset_spin_lock lock(it->val_lock,30);
uniset_rwmutex_wrlock lock(it->val_lock);
if( it->type == UniversalIO::DigitalInput ||
it->type == UniversalIO::DigitalOutput )
{
......
extensions/UniNetwork/UniExchange.h
View file @ afa40939
......@@ -78,7 +78,7 @@ class UniExchange:
long val;
long id;
UniversalIO::IOTypes type;
UniSetTypes::uniset_spin_mutex val_lock;
UniSetTypes::uniset_rwmutex val_lock;
};
typedef std::vector<SInfo> SList;
......
extensions/include/IOBase.h
View file @ afa40939
......@@ -106,7 +106,7 @@ static const int NoSafety = -1;
IOController::AIOStateList::iterator ait;
IOController::DIOStateList::iterator dit;
UniSetTypes::uniset_spin_mutex val_lock; /*!< блокировка на время "работы" со значением */
UniSetTypes::uniset_rwmutex val_lock; /*!< блокировка на время "работы" со значением */
friend std::ostream& operator<<(std::ostream& os, IOBase& inf );
......
extensions/include/SMInterface.h
View file @ afa40939
......@@ -89,6 +89,7 @@ class SMInterface
CORBA::Object_var oref;
UniSetTypes::ObjectId shmID;
UniSetTypes::ObjectId myid;
UniSetTypes::uniset_rwmutex shmMutex;
};
//--------------------------------------------------------------------------
......
extensions/lib/IOBase.cc
View file @ afa40939
......@@ -121,7 +121,7 @@ void IOBase::processingAsAI( IOBase* it, long val, SMInterface* shm, bool force
// проверка на обрыв
if( it->check_channel_break(val) )
{
uniset_spin_lock lock(it->val_lock);
uniset_rwmutex_wrlock lock(it->val_lock);
it->value = ChannelBreakValue;
shm->localSetUndefinedState(it->ait,true,it->si.id);
return;
......@@ -170,7 +170,7 @@ void IOBase::processingAsAI( IOBase* it, long val, SMInterface* shm, bool force
// если предыдущее значение "обрыв",
// то сбрасываем признак
{
uniset_spin_lock lock(it->val_lock);
uniset_rwmutex_wrlock lock(it->val_lock);
if( it->value == ChannelBreakValue )
shm->localSetUndefinedState(it->ait,false,it->si.id);
......@@ -200,7 +200,7 @@ void IOBase::processingFasAI( IOBase* it, float fval, SMInterface* shm, bool for
// проверка на обрыв
if( it->check_channel_break(val) )
{
uniset_spin_lock lock(it->val_lock);
uniset_rwmutex_wrlock lock(it->val_lock);
it->value = ChannelBreakValue;
shm->localSetUndefinedState(it->ait,true,it->si.id);
return;
......@@ -228,7 +228,7 @@ void IOBase::processingFasAI( IOBase* it, float fval, SMInterface* shm, bool for
// если предыдущее значение "обрыв",
// то сбрасываем признак
{
uniset_spin_lock lock(it->val_lock);
uniset_rwmutex_wrlock lock(it->val_lock);
if( it->value == ChannelBreakValue )
shm->localSetUndefinedState(it->ait,false,it->si.id);
......@@ -262,7 +262,7 @@ void IOBase::processingAsDI( IOBase* it, bool set, SMInterface* shm, bool force
set = it->check_off_delay(set); // фильтр на отпускание
{
uniset_spin_lock lock(it->val_lock);
uniset_rwmutex_wrlock lock(it->val_lock);
if( force || (bool)it->value!=set )
{
if( it->stype == UniversalIO::DigitalInput )
......@@ -281,7 +281,7 @@ void IOBase::processingAsDI( IOBase* it, bool set, SMInterface* shm, bool force
// -----------------------------------------------------------------------------
long IOBase::processingAsAO( IOBase* it, SMInterface* shm, bool force )
{
uniset_spin_lock lock(it->val_lock);
uniset_rwmutex_rlock lock(it->val_lock);
long val = it->value;
// проверка зависимости
......@@ -338,7 +338,7 @@ bool IOBase::processingAsDO( IOBase* it, SMInterface* shm, bool force )
if( !it->check_depend(shm) )
return (bool)it->d_off_value;
uniset_spin_lock lock(it->val_lock);
uniset_rwmutex_rlock lock(it->val_lock);
bool set = it->value;
if( force )
......@@ -359,7 +359,7 @@ float IOBase::processingFasAO( IOBase* it, SMInterface* shm, bool force )
if( !it->check_depend(shm) )
return (float)it->d_off_value;
uniset_spin_lock lock(it->val_lock);
uniset_rwmutex_rlock lock(it->val_lock);
long val = it->value;
if( force )
......
extensions/lib/SMInterface.cc
View file @ afa40939
......@@ -10,7 +10,7 @@ using namespace UniSetTypes;
#define BEG_FUNC(name) \
try \
{ \
uniset_mutex_lock l(shmMutex,500); \
uniset_rwmutex_wrlock l(shmMutex); \
IONotifyController_i_var shm;\
for( unsigned int i=0; i<conf->getRepeatCount(); i++)\
{\
......@@ -33,7 +33,7 @@ using namespace UniSetTypes;
#define BEG_FUNC1(name) \
try \
{ \
uniset_mutex_lock l(shmMutex,500); \
uniset_rwmutex_wrlock l(shmMutex); \
if( true ) \
{ \
try \
......
include/IOController.h
View file @ afa40939
......@@ -164,7 +164,7 @@ class IOController:
bool block_state;
bool db_ignore; /*!< не писать изменения в БД */
UniSetTypes::uniset_spin_mutex val_lock; /*!< флаг блокирующий работу со значением */
UniSetTypes::uniset_rwmutex val_lock; /*!< флаг блокирующий работу со значением */
};
struct UniAnalogIOInfo:
......@@ -188,7 +188,7 @@ class IOController:
long block_value;
bool db_ignore; /*!< не писать изменения в БД */
UniSetTypes::uniset_spin_mutex val_lock; /*!< флаг блокирующий работу со значением */
UniSetTypes::uniset_rwmutex val_lock; /*!< флаг блокирующий работу со значением */
};
......@@ -377,8 +377,8 @@ class IOController:
DIOStateList dioList; /*!< список с текущим состоянием дискретных входов/выходов */
AIOStateList aioList; /*!< список с текущим состоянием аналоговых входов/выходов */
UniSetTypes::uniset_mutex dioMutex; /*!< замок для блокирования совместного доступа к dioList */
UniSetTypes::uniset_mutex aioMutex; /*!< замок для блокирования совместного доступа к aioList */
UniSetTypes::uniset_rwmutex dioMutex; /*!< замок для блокирования совместного доступа к dioList */
UniSetTypes::uniset_rwmutex aioMutex; /*!< замок для блокирования совместного доступа к aioList */
bool isPingDBServer; // флаг связи с DBServer-ом
......@@ -389,7 +389,8 @@ class IOController:
DependsSlot bslot; /*!< block depends slot */
int checkLockValuePause;
UniSetTypes::uniset_mutex loggingMutex; /*!< logging info mutex */
UniSetTypes::uniset_rwmutex loggingMutex; /*!< logging info mutex */
};
// --------------------------------------------------------------------------
#endif
// --------------------------------------------------------------------------
include/IONotifyController.h
View file @ afa40939
......@@ -278,7 +278,7 @@ class IONotifyController:
void onChangeUndefined( DependsList::iterator it, bool undefined );
UniSetTypes::uniset_mutex sig_mutex;
UniSetTypes::uniset_rwmutex sig_mutex;
ChangeSignal changeSignal;
private:
......@@ -307,17 +307,18 @@ class IONotifyController:
AskMap askAOList; /*!< список потребителей по аналоговым выходам */
/*! замок для блокирования совместного доступа к cписку потребителей дискретных датчиков */
UniSetTypes::uniset_mutex askDMutex;
UniSetTypes::uniset_rwmutex askDMutex;
/*! замок для блокирования совместного доступа к cписку потребителей аналоговых датчиков */
UniSetTypes::uniset_mutex askAMutex;
UniSetTypes::uniset_rwmutex askAMutex;
/*! замок для блокирования совместного доступа к cписку потребителей пороговых датчиков */
UniSetTypes::uniset_mutex trshMutex;
UniSetTypes::uniset_rwmutex trshMutex;
/*! замок для блокирования совместного доступа к cписку потребителей аналоговых выходов */
UniSetTypes::uniset_mutex askAOMutex;
UniSetTypes::uniset_rwmutex askAOMutex;
/*! замок для блокирования совместного доступа к cписку потребителей дискретных выходов */
UniSetTypes::uniset_mutex askDOMutex;
UniSetTypes::uniset_rwmutex askDOMutex;
int maxAttemtps; /*! timeout for consumer */
};
// --------------------------------------------------------------------------
#endif
// --------------------------------------------------------------------------
include/LT_Object.h
View file @ afa40939
......@@ -182,7 +182,7 @@ class LT_Object
private:
TimersList tlst;
/*! замок для блокирования совместного доступа к cписку таймеров */
UniSetTypes::uniset_mutex lstMutex;
UniSetTypes::uniset_rwmutex lstMutex;
timeout_t sleepTime; /*!< текущее время ожидания */
PassiveTimer tmLast;
};
......
include/Mutex.h
View file @ afa40939
......@@ -51,6 +51,7 @@ namespace UniSetTypes
void unlock();
inline std::string name(){ return nm; }
inline void setName( const std::string& name ){ nm = name; }
protected:
......@@ -65,6 +66,8 @@ namespace UniSetTypes
mutex_atomic_t locked;
};
std::ostream& operator<<(std::ostream& os, uniset_mutex& m );
// -------------------------------------------------------------------------
/*! \class uniset_mutex_lock
* \author Pavel Vainerman
*
......@@ -90,11 +93,12 @@ namespace UniSetTypes
// -------------------------------------------------------------------------
// Mutex c приоритетом WRlock над RLock...
class uniset_spin_mutex
class uniset_rwmutex
{
public:
uniset_spin_mutex();
~uniset_spin_mutex();
uniset_rwmutex( const std::string& name );
uniset_rwmutex();
~uniset_rwmutex();
void lock( int check_pause_msec=1 );
void unlock();
......@@ -102,54 +106,43 @@ namespace UniSetTypes
void wrlock( int check_pause_msec=1 );
void rlock( int check_pause_msec=1 );
uniset_spin_mutex (const uniset_spin_mutex& r);
const uniset_spin_mutex &operator=(const uniset_spin_mutex& r);
uniset_rwmutex (const uniset_rwmutex& r);
const uniset_rwmutex &operator=(const uniset_rwmutex& r);
inline std::string name(){ return nm; }
inline void setName( const std::string& name ){ nm = name; }
private:
friend class uniset_spin_lock;
std::string nm;
friend class uniset_rwmutex_lock;
ost::ThreadLock m;
ost::AtomicCounter wr_wait;
};
std::ostream& operator<<(std::ostream& os, uniset_rwmutex& m );
// -------------------------------------------------------------------------
class uniset_spin_lock
class uniset_rwmutex_wrlock
{
public:
uniset_spin_lock( uniset_spin_mutex& m, int check_pause_msec );
~uniset_spin_lock();
protected:
uniset_spin_lock( uniset_spin_mutex& _m ): m(_m){}
uniset_spin_mutex& m;
uniset_rwmutex_wrlock( uniset_rwmutex& m, int check_pause_msec=1 );
~uniset_rwmutex_wrlock();
private:
uniset_spin_lock(const uniset_spin_lock&);
uniset_spin_lock& operator=(const uniset_spin_lock&);
uniset_rwmutex_wrlock(const uniset_rwmutex_wrlock&);
uniset_rwmutex_wrlock& operator=(const uniset_rwmutex_wrlock&);
uniset_rwmutex& m;
};
class uniset_spin_wrlock:
protected uniset_spin_lock
class uniset_rwmutex_rlock
{
public:
uniset_spin_wrlock( uniset_spin_mutex& m, int check_pause_msec=1 );
~uniset_spin_wrlock();
uniset_rwmutex_rlock( uniset_rwmutex& m, int check_pause_msec=5 );
~uniset_rwmutex_rlock();
private:
uniset_spin_wrlock(const uniset_spin_wrlock&);
uniset_spin_wrlock& operator=(const uniset_spin_wrlock&);
uniset_rwmutex_rlock(const uniset_rwmutex_rlock&);
uniset_rwmutex_rlock& operator=(const uniset_rwmutex_rlock&);
uniset_rwmutex& m;
};
class uniset_spin_rlock:
protected uniset_spin_lock
{
public:
uniset_spin_rlock( uniset_spin_mutex& m, int check_pause_msec=5 );
~uniset_spin_rlock();
private:
uniset_spin_rlock(const uniset_spin_rlock&);
uniset_spin_rlock& operator=(const uniset_spin_rlock&);
};
// -------------------------------------------------------------------------
} // end of UniSetTypes namespace
......
include/ObjectsManager.h
View file @ afa40939
......@@ -59,7 +59,7 @@ class ObjectsManager:
{
public:
ObjectsManager( UniSetTypes::ObjectId id);
ObjectsManager( const std::string name, const std::string section );
ObjectsManager( const std::string& name, const std::string& section );
virtual ~ObjectsManager();
......@@ -153,9 +153,8 @@ class ObjectsManager:
ObjectsManagerList mlist;
ObjectsList olist;
UniSetTypes::uniset_mutex olistMutex;
UniSetTypes::uniset_mutex mlistMutex;
UniSetTypes::uniset_rwmutex olistMutex;
UniSetTypes::uniset_rwmutex mlistMutex;
};
#endif
include/PosixThread.h deleted 100644 → 0
View file @ 3b35d826
/* This file is part of the UniSet project
* Copyright (c) 2002 Free Software Foundation, Inc.
* Copyright (c) 2002 Pavel Vainerman
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
// --------------------------------------------------------------------------
/*! \file
* \brief Интефес для создания и управления потоками
* \author Anthony Korbin
*/
//----------------------------------------------------------------------------
#ifndef PosixThread_h_
#define PosixThread_h_
//----------------------------------------------------------------------------------------
#include <pthread.h>
#include <iostream>
#include <signal.h>
//----------------------------------------------------------------------------------------
/*! \class PosixThread */
class PosixThread
{
public:
PosixThread();
virtual ~PosixThread();
void start( void *args ); /*!< запуск */
void stop();
void thrkill( int signo ); /*!< послать сигнал signo */
enum TAttr{ SCOPE, DETACH, PRIORITY };
void setAttr( TAttr Attr, int state );
pthread_t getTID(){ return tid; }
void setPriority( int priority );
static void* funcp( void * test );
protected:
void reinit();
virtual void work() = 0; /*!< Функция выполняемая в потоке */
void readlock( pthread_rwlock_t *lock = &lockx );
void writelock( pthread_rwlock_t *lock = &lockx );
void lock( pthread_mutex_t *mute = &mutex );
void unlock( pthread_mutex_t *mute = &mutex );
void rwunlock( pthread_rwlock_t *lock = &lockx );
void wait( pthread_cond_t *cond = &condx, pthread_mutex_t *mute = &mutex );
void continueRun( pthread_cond_t *cond = &condx );
void continueRunAll( pthread_cond_t *cond = &condx );
private:
pthread_t tid;
pthread_attr_t *attrPtr;
static pthread_rwlock_t lockx;
static pthread_mutex_t mutex;
static pthread_cond_t condx;
static int countThreads;
};
//----------------------------------------------------------------------------------------
#endif // PosixThread_h_
//----------------------------------------------------------------------------------------
include/UniSetObject.h
View file @ afa40939
......@@ -65,7 +65,7 @@ class UniSetObject:
public POA_UniSetObject_i
{
public:
UniSetObject(const std::string name, const std::string section);
UniSetObject(const std::string& name, const std::string& section);
UniSetObject(UniSetTypes::ObjectId id);
UniSetObject();
virtual ~UniSetObject();
......@@ -84,7 +84,7 @@ class UniSetObject:
/*! получить ссылку (на себя) */
inline UniSetTypes::ObjectPtr getRef()
{
UniSetTypes::uniset_mutex_lock lock(refmutex, 300);
UniSetTypes::uniset_rwmutex_rlock lock(refmutex);
return (UniSetTypes::ObjectPtr)CORBA::Object::_duplicate(oref);
}
......@@ -179,13 +179,6 @@ class UniSetObject:
*/
virtual void cleanMsgQueue( MessagesQueue& q );
void setRecvMutexTimeout( unsigned long msec );
inline unsigned long getRecvMutexTimeout(){ return recvMutexTimeout; }
void setPushMutexTimeout( unsigned long msec );
unsigned long getPushMutexTimeout(){ return pushMutexTimeout; }
bool isActive();
void setActive( bool set );
......@@ -222,7 +215,7 @@ class UniSetObject:
pid_t msgpid; // pid потока обработки сообщений
bool reg;
bool active;
UniSetTypes::uniset_mutex act_mutex;
UniSetTypes::uniset_rwmutex mutex_act;
bool threadcreate;
UniSetTimer* tmr;
UniSetTypes::ObjectId myid;
......@@ -233,17 +226,15 @@ class UniSetObject:
MessagesQueue queueMsg;
/*! замок для блокирования совместного доступа к очереди */
UniSetTypes::uniset_mutex qmutex;
UniSetTypes::uniset_rwmutex qmutex;
/*! замок для блокирования совместного доступа к очереди */
UniSetTypes::uniset_mutex refmutex;
UniSetTypes::uniset_rwmutex refmutex;
/*! размер очереди сообщений (при превышении происходит очистка) */
unsigned int SizeOfMessageQueue;
/*! сколько сообщений удалять при очисте*/
unsigned int MaxCountRemoveOfMessage;
unsigned long recvMutexTimeout; /*!< таймаут на ожидание освобождения mutex-а при receiveMessage */
unsigned long pushMutexTimeout; /*!< таймаут на ожидание освобождения mutex-а при pushMessage */
// статистическая информация
unsigned long stMaxQueueMessages; /*<! Максимальное число сообщений хранившихся в очереди */
......
include/UniSetTypes.h
View file @ afa40939
......@@ -146,9 +146,6 @@ namespace UniSetTypes
/*! Запрещенные для использования в именах объектов символы */
const char BadSymbols[]={'.','/'};
class uniset_mutex;
class uniset_mutex_lock;
/// Преобразование строки в число (воспринимает префикс 0, как 8-ное, префикс 0x, как 16-ное, минус для отриц. чисел)
inline int uni_atoi( const char* str )
{
......
include/UniversalInterface.h
View file @ afa40939
......@@ -324,7 +324,7 @@ class UniversalInterface
bool clean(); /*!< функция очистки кэш-а от старых ссылок */
inline void clear() /*!< удаление всей информации */
{
UniSetTypes::uniset_mutex_lock l(cmutex,200);
UniSetTypes::uniset_rwmutex_wrlock l(cmutex);
mcache.clear();
};
......@@ -355,7 +355,7 @@ class UniversalInterface
typedef std::map<int, Info> CacheMap;
CacheMap mcache;
UniSetTypes::uniset_mutex cmutex;
UniSetTypes::uniset_rwmutex cmutex;
unsigned int MaxSize; /*!< максимальный размер кэша */
unsigned int CleanTime; /*!< период устаревания ссылок [мин] */
......
include/modbus/ModbusClient.h
View file @ afa40939
......@@ -193,7 +193,7 @@ class ModbusClient
bool crcNoCheckit;
UniSetTypes::uniset_mutex sendMutex;
UniSetTypes::uniset_rwmutex sendMutex;
DebugStream dlog;
void printProcessingTime();
......
include/modbus/ModbusRTUSlave.h
View file @ afa40939
......@@ -23,12 +23,12 @@ class ModbusRTUSlave:
public ModbusServer
{
public:
ModbusRTUSlave( const std::string dev, bool use485=false, bool tr_ctl=false );
ModbusRTUSlave( const std::string& dev, bool use485=false, bool tr_ctl=false );
ModbusRTUSlave( ComPort* com );
virtual ~ModbusRTUSlave();
void setSpeed( ComPort::Speed s );
void setSpeed( const std::string s );
void setSpeed( const std::string& s );
ComPort::Speed getSpeed();
virtual ModbusRTU::mbErrCode receive( ModbusRTU::ModbusAddr addr, timeout_t msecTimeout );
......
include/modbus/TCPCheck.h
View file @ afa40939
......@@ -26,7 +26,7 @@ class TCPCheck
void check_thread();
inline void setResult( bool res )
{
UniSetTypes::uniset_mutex_lock l(m,50);
UniSetTypes::uniset_rwmutex_wrlock l(m);
result = res;
}
......@@ -34,7 +34,7 @@ class TCPCheck
{
bool res = false;
{
UniSetTypes::uniset_mutex_lock l(m,50);
UniSetTypes::uniset_rwmutex_rlock l(m);
res = result;
}
return res;
......@@ -43,7 +43,7 @@ class TCPCheck
bool result;
std::string iaddr;
int tout_msec;
UniSetTypes::uniset_mutex m;
UniSetTypes::uniset_rwmutex m;
};
// -----------------------------------------------------------------------------
#endif // _TCPCheck_H_
......
src/Communications/Modbus/ModbusClient.cc
View file @ afa40939
......@@ -14,7 +14,8 @@ ModbusClient::ModbusClient():
replyTimeOut_ms(2000),
aftersend_msec(0),
sleepPause_usec(100),
crcNoCheckit(false)
crcNoCheckit(false),
sendMutex("ModbusClient_sendMutex")
{
tmProcessing.setTiming(replyTimeOut_ms);
}
......
src/Communications/Modbus/ModbusRTUSlave.cc
View file @ afa40939
......@@ -11,10 +11,12 @@ using namespace std;
using namespace ModbusRTU;
using namespace UniSetTypes;
// -------------------------------------------------------------------------
ModbusRTUSlave::ModbusRTUSlave( const string dev, bool use485, bool tr_ctl ):
ModbusRTUSlave::ModbusRTUSlave( const string& dev, bool use485, bool tr_ctl ):
port(NULL),
myport(true)
{
recvMutex.setName("(ModbusRTUSlave): dev='" + dev + "' recvMutex:");
if( use485 )
{
ComPort485F* cp;
......@@ -63,6 +65,13 @@ ModbusRTUSlave::~ModbusRTUSlave()
mbErrCode ModbusRTUSlave::receive( ModbusRTU::ModbusAddr addr, timeout_t timeout )
{
uniset_mutex_lock lck(recvMutex,timeout);
if( !lck.lock_ok() )
{
if( dlog.debugging(Debug::CRIT) )
dlog[Debug::CRIT] << "(ModbusRTUSlave::receive): Don`t lock " << recvMutex << endl;
return erTimeOut;
}
ModbusMessage buf;
mbErrCode res = erBadReplyNodeAddress;
do
......@@ -114,7 +123,7 @@ void ModbusRTUSlave::setSpeed( ComPort::Speed s )
port->setSpeed(s);
}
// --------------------------------------------------------------------------------
void ModbusRTUSlave::setSpeed( const std::string s )
void ModbusRTUSlave::setSpeed( const std::string& s )
{
if( port != NULL )
port->setSpeed(s);
......
src/Communications/Modbus/ModbusServer.cc
View file @ afa40939
......@@ -15,6 +15,7 @@ using namespace ModbusRTU;
using namespace UniSetTypes;
// -------------------------------------------------------------------------
ModbusServer::ModbusServer():
recvMutex("ModbusServer_recvMutex"),
recvTimeOut_ms(50),
replyTimeout_ms(2000),
aftersend_msec(0),
......
src/Interfaces/UniversalInterface.cc
View file @ afa40939
......@@ -2377,7 +2377,7 @@ IOController_i::ShortIOInfo UniversalInterface::getChangedTime( UniSetTypes::Obj
ObjectPtr UniversalInterface::CacheOfResolve::resolve( ObjectId id, ObjectId node )
throw(NameNotFound)
{
UniSetTypes::uniset_mutex_lock l(cmutex,200);
UniSetTypes::uniset_rwmutex_rlock l(cmutex);
//#warning Временно отключён кэш
// throw UniSetTypes::NameNotFound();
......@@ -2400,16 +2400,7 @@ ObjectPtr UniversalInterface::CacheOfResolve::resolve( ObjectId id, ObjectId nod
// ------------------------------------------------------------------------------------------------------------
void UniversalInterface::CacheOfResolve::cache( ObjectId id, ObjectId node, ObjectVar ptr )
{
UniSetTypes::uniset_mutex_lock l(cmutex,220);
//#warning Временно отключён кэш
// return;
// if( mcache.size() > MaxSize )
// {
// if( !clean() )
// unideb[Debug::CRIT] << "UI(resolve cache): не удалось уменьшить размер кэш-а!!!!"<< endl;
// }
UniSetTypes::uniset_rwmutex_wrlock l(cmutex);
UniSetTypes::KeyType k(key(id,node));
CacheMap::iterator it = mcache.find(k);
......@@ -2424,13 +2415,12 @@ void UniversalInterface::CacheOfResolve::cache( ObjectId id, ObjectId node, Obje
// ------------------------------------------------------------------------------------------------------------
bool UniversalInterface::CacheOfResolve::clean()
{
UniSetTypes::uniset_mutex_lock l(cmutex,180);
// return true;
UniSetTypes::uniset_rwmutex_wrlock l(cmutex);
if( unideb.debugging(Debug::INFO) )
unideb[Debug::INFO] << "UI: clean cache...."<< endl;
unideb[Debug::INFO] << "UI: clean cache...."<< endl;
time_t tm = time(NULL)-CleanTime*60;
time_t tm = time(NULL)-CleanTime*60;
// remove_if(mcache.begin(), mcache.end(),OldRef_eq(tm));
for( CacheMap::iterator it=mcache.begin(); it!=mcache.end();)
{
......@@ -2449,7 +2439,7 @@ bool UniversalInterface::CacheOfResolve::clean()
void UniversalInterface::CacheOfResolve::erase( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node )
{
UniSetTypes::uniset_mutex_lock l(cmutex,220);
UniSetTypes::uniset_rwmutex_wrlock l(cmutex);
//#warning Временно отключён кэш
// return;
......
src/ObjectRepository/ObjectsActivator.cc
View file @ afa40939
......@@ -270,22 +270,28 @@ void ObjectsActivator::work()
}
catch(CORBA::SystemException& ex)
{
unideb[Debug::CRIT] << myname << "(work): поймали CORBA::SystemException: " << ex.NP_minorString() << endl;
if( unideb.debugging(Debug::CRIT) )
unideb[Debug::CRIT] << myname << "(work): поймали CORBA::SystemException: " << ex.NP_minorString() << endl;
}
catch(CORBA::Exception& ex)
{
unideb[Debug::CRIT] << myname << "(work): поймали CORBA::Exception." << endl;
if( unideb.debugging(Debug::CRIT) )
unideb[Debug::CRIT] << myname << "(work): поймали CORBA::Exception." << endl;
}
catch(omniORB::fatalException& fe)
{
unideb[Debug::CRIT] << myname << "(work): : поймали omniORB::fatalException:" << endl;
unideb[Debug::CRIT] << myname << "(work): file: " << fe.file() << endl;
unideb[Debug::CRIT] << myname << "(work): line: " << fe.line() << endl;
unideb[Debug::CRIT] << myname << "(work): mesg: " << fe.errmsg() << endl;
if( unideb.debugging(Debug::CRIT) )
{
unideb[Debug::CRIT] << myname << "(work): : поймали omniORB::fatalException:" << endl;
unideb[Debug::CRIT] << myname << "(work): file: " << fe.file() << endl;
unideb[Debug::CRIT] << myname << "(work): line: " << fe.line() << endl;
unideb[Debug::CRIT] << myname << "(work): mesg: " << fe.errmsg() << endl;
}
}
catch(...)
{
unideb[Debug::CRIT] << myname << "(work): catch ..." << endl;
if( unideb.debugging(Debug::CRIT) )
unideb[Debug::CRIT] << myname << "(work): catch ..." << endl;
}
if( unideb.debugging(Debug::SYSTEM) )
......
src/ObjectRepository/ObjectsManager.cc
View file @ afa40939
......@@ -80,22 +80,29 @@ class OPush: public unary_function<UniSetObject*, bool>
// ------------------------------------------------------------------------------------------
ObjectsManager::ObjectsManager():
UniSetObject(UniSetTypes::DefaultObjectId)
UniSetObject(UniSetTypes::DefaultObjectId),
sig(0),
olistMutex("olistMutex"),
mlistMutex("mlistMutex")
{
}
// ------------------------------------------------------------------------------------------
ObjectsManager::ObjectsManager( ObjectId id):
ObjectsManager::ObjectsManager( ObjectId id ):
UniSetObject(id),
sig(0)
{
olistMutex.setName(myname + "_olistMutex");
mlistMutex.setName(myname + "_mlistMutex");
}
// ------------------------------------------------------------------------------------------
ObjectsManager::ObjectsManager(const string name, const string section):
ObjectsManager::ObjectsManager(const string& name, const string& section):
UniSetObject(name, section),
sig(0)
{
olistMutex.setName(myname + "_olistMutex");
mlistMutex.setName(myname + "_mlistMutex");
}
// ------------------------------------------------------------------------------------------
......@@ -141,7 +148,7 @@ void ObjectsManager::initPOA( ObjectsManager* rmngr )
bool ObjectsManager::addObject( UniSetObject *obj )
{
{ //lock
uniset_mutex_lock lock(olistMutex, 1000);
uniset_rwmutex_wrlock lock(olistMutex);
ObjectsList::iterator li=find(olist.begin(),olist.end(), obj);
if( li==olist.end() )
{
......@@ -157,7 +164,7 @@ bool ObjectsManager::addObject( UniSetObject *obj )
bool ObjectsManager::removeObject(UniSetObject* obj)
{
{ //lock
uniset_mutex_lock lock(olistMutex, 1000);
uniset_rwmutex_wrlock lock(olistMutex);
ObjectsList::iterator li=find(olist.begin(),olist.end(), obj);
if( li!=olist.end() )
{
......@@ -193,7 +200,7 @@ bool ObjectsManager::removeObject(UniSetObject* obj)
} // unlock
return true;
}
}
// ------------------------------------------------------------------------------------------
/*!
......@@ -201,10 +208,11 @@ bool ObjectsManager::removeObject(UniSetObject* obj)
*/
void ObjectsManager::managers(OManagerCommand cmd)
{
unideb[Debug::INFO] << myname <<"(managers): mlist.size="
if( unideb.debugging(Debug::INFO) )
unideb[Debug::INFO] << myname <<"(managers): mlist.size="
<< mlist.size() << " cmd=" << cmd << endl;
{ //lock
uniset_mutex_lock lock(mlistMutex, 1000);
uniset_rwmutex_rlock lock(mlistMutex);
for( ObjectsManagerList::iterator li=mlist.begin();li!=mlist.end();++li )
{
try
......@@ -233,23 +241,31 @@ void ObjectsManager::managers(OManagerCommand cmd)
}
catch( Exception& ex )
{
unideb[Debug::CRIT] << myname << "(managers): " << ex << endl;
unideb[Debug::CRIT] << myname << "(managers): не смог зарегистрировать (разрегистрировать) объект -->"<< (*li)->getName() << endl;
if( unideb.debugging(Debug::CRIT) )
{
unideb[Debug::CRIT] << myname << "(managers): " << ex << endl;
unideb[Debug::CRIT] << myname << "(managers): не смог зарегистрировать (разрегистрировать) объект -->"<< (*li)->getName() << endl;
}
}
catch(CORBA::SystemException& ex)
{
unideb[Debug::CRIT] << myname << "(managers): поймали CORBA::SystemException:" << ex.NP_minorString() << endl;
if( unideb.debugging(Debug::CRIT) )
unideb[Debug::CRIT] << myname << "(managers): поймали CORBA::SystemException:" << ex.NP_minorString() << endl;
}
catch( CORBA::Exception& ex )
{
unideb[Debug::CRIT] << myname << "(managers): Caught CORBA::Exception. " << ex._name() << endl;
if( unideb.debugging(Debug::CRIT) )
unideb[Debug::CRIT] << myname << "(managers): Caught CORBA::Exception. " << ex._name() << endl;
}
catch( omniORB::fatalException& fe )
{
unideb[Debug::CRIT] << myname << "(managers): Caught omniORB::fatalException:" << endl;
unideb[Debug::CRIT] << myname << "(managers): file: " << fe.file()
<< " line: " << fe.line()
<< " mesg: " << fe.errmsg() << endl;
if( unideb.debugging(Debug::CRIT) )
{
unideb[Debug::CRIT] << myname << "(managers): Caught omniORB::fatalException:" << endl;
unideb[Debug::CRIT] << myname << "(managers): file: " << fe.file()
<< " line: " << fe.line()
<< " mesg: " << fe.errmsg() << endl;
}
}
}
} // unlock
......@@ -260,10 +276,11 @@ void ObjectsManager::managers(OManagerCommand cmd)
*/
void ObjectsManager::objects(OManagerCommand cmd)
{
unideb[Debug::INFO] << myname <<"(objects): olist.size="
if( unideb.debugging(Debug::INFO) )
unideb[Debug::INFO] << myname <<"(objects): olist.size="
<< olist.size() << " cmd=" << cmd << endl;
{ //lock
uniset_mutex_lock lock(olistMutex, 1000);
uniset_rwmutex_rlock lock(olistMutex);
for (ObjectsList::iterator li=olist.begin();li!=olist.end();++li)
{
......@@ -293,25 +310,33 @@ void ObjectsManager::objects(OManagerCommand cmd)
}
catch( Exception& ex )
{
unideb[Debug::CRIT] << myname << "(objects): " << ex << endl;
unideb[Debug::CRIT] << myname << "(objects): не смог зарегистрировать (разрегистрировать) объект -->"<< (*li)->getName() << endl;
if( unideb.debugging(Debug::CRIT) )
{
unideb[Debug::CRIT] << myname << "(objects): " << ex << endl;
unideb[Debug::CRIT] << myname << "(objects): не смог зарегистрировать (разрегистрировать) объект -->"<< (*li)->getName() << endl;
}
}
catch(CORBA::SystemException& ex)
{
unideb[Debug::CRIT] << myname << "(objects): поймали CORBA::SystemException:" << ex.NP_minorString() << endl;
if( unideb.debugging(Debug::CRIT) )
unideb[Debug::CRIT] << myname << "(objects): поймали CORBA::SystemException:" << ex.NP_minorString() << endl;
}
catch( CORBA::Exception& ex )
{
unideb[Debug::CRIT] << myname << "(objects): Caught CORBA::Exception. "
<< ex._name()
<< " (" << (*li)->getName() << ")" << endl;
if( unideb.debugging(Debug::CRIT) )
unideb[Debug::CRIT] << myname << "(objects): Caught CORBA::Exception. "
<< ex._name()
<< " (" << (*li)->getName() << ")" << endl;
}
catch( omniORB::fatalException& fe )
{
unideb[Debug::CRIT] << myname << "(objects): Caught omniORB::fatalException:" << endl;
unideb[Debug::CRIT] << myname << "(objects): file: " << fe.file()
<< " line: " << fe.line()
<< " mesg: " << fe.errmsg() << endl;
if( unideb.debugging(Debug::CRIT) )
{
unideb[Debug::CRIT] << myname << "(objects): Caught omniORB::fatalException:" << endl;
unideb[Debug::CRIT] << myname << "(objects): file: " << fe.file()
<< " line: " << fe.line()
<< " mesg: " << fe.errmsg() << endl;
}
}
}
} // unlock
......@@ -362,13 +387,13 @@ void ObjectsManager::broadcast(const TransportMessage& msg)
// Всем объектам...
{ //lock
uniset_mutex_lock lock(olistMutex, 2000);
uniset_rwmutex_rlock lock(olistMutex);
for_each(olist.begin(),olist.end(),OPush(msg)); // STL метод
} // unlock
// Всем менеджерам....
{ //lock
uniset_mutex_lock lock(mlistMutex, 2000);
uniset_rwmutex_rlock lock(mlistMutex);
for_each(mlist.begin(),mlist.end(),MPush(msg)); // STL метод
} // unlock
}
......@@ -377,7 +402,7 @@ void ObjectsManager::broadcast(const TransportMessage& msg)
bool ObjectsManager::addManager( ObjectsManager *child )
{
{ //lock
uniset_mutex_lock lock(mlistMutex, 1000);
uniset_rwmutex_wrlock lock(mlistMutex);
// Проверка на совпадение
ObjectsManagerList::iterator it= find(mlist.begin(),mlist.end(),child);
......@@ -387,7 +412,7 @@ bool ObjectsManager::addManager( ObjectsManager *child )
if( unideb.debugging(Debug::INFO) )
unideb[Debug::INFO] << myname << ": добавляем менеджер "<< child->getName()<< endl;
}
else
else if( unideb.debugging(Debug::WARN) )
unideb[Debug::WARN] << myname << ": попытка повторного добавления объекта "<< child->getName() << endl;
} // unlock
......@@ -398,7 +423,7 @@ bool ObjectsManager::addManager( ObjectsManager *child )
bool ObjectsManager::removeManager( ObjectsManager* child )
{
{ //lock
uniset_mutex_lock lock(mlistMutex, 1000);
uniset_rwmutex_wrlock lock(mlistMutex);
mlist.remove(child);
} // unlock
......@@ -411,7 +436,7 @@ const ObjectsManager* ObjectsManager::itemM(const ObjectId id)
{
{ //lock
uniset_mutex_lock lock(mlistMutex, 1000);
uniset_rwmutex_rlock lock(mlistMutex);
for( ObjectsManagerList::iterator li=mlist.begin(); li!=mlist.end();++li )
{
if ( (*li)->getId()==id )
......@@ -427,7 +452,7 @@ const ObjectsManager* ObjectsManager::itemM(const ObjectId id)
const UniSetObject* ObjectsManager::itemO(const ObjectId id)
{
{ //lock
uniset_mutex_lock lock(olistMutex, 1000);
uniset_rwmutex_rlock lock(olistMutex);
for (ObjectsList::iterator li=olist.begin(); li!=olist.end();++li)
{
if ( (*li)->getId()==id )
......
src/ObjectRepository/UniSetObject.cc
View file @ afa40939
......@@ -101,7 +101,7 @@ stCountOfQueueFull(0)
}
UniSetObject::UniSetObject(const string name, const string section):
UniSetObject::UniSetObject(const string& name, const string& section):
ui(UniSetTypes::DefaultObjectId),
mymngr(NULL),
msgpid(0),
......@@ -137,11 +137,18 @@ UniSetObject::~UniSetObject()
disactivate();
delete tmr;
if(thr)
{
thr->stop();
delete thr;
}
}
// ------------------------------------------------------------------------------------------
void UniSetObject::init_object()
{
qmutex.setName(myname + "_qmutex");
refmutex.setName(myname + "_refmutex");
mutex_act.setName(myname + "_mutex_act");
SizeOfMessageQueue = conf->getArgPInt("--uniset-object-size-message-queue",conf->getField("SizeOfMessageQueue"), 1000);
MaxCountRemoveOfMessage = conf->getArgInt("--uniset-object-maxcount-remove-message",conf->getField("MaxCountRemoveOfMessage"));
......@@ -149,16 +156,11 @@ void UniSetObject::init_object()
MaxCountRemoveOfMessage = SizeOfMessageQueue / 4;
if( MaxCountRemoveOfMessage <= 0 )
MaxCountRemoveOfMessage = 10;
recvMutexTimeout = conf->getArgPInt("--uniset-object-receive-mutex-timeout",conf->getField("RecvMutexTimeout"), 10000);
pushMutexTimeout = conf->getArgPInt("--uniset-object-push-mutex-timeout",conf->getField("PushMutexTimeout"), 9000);
if( unideb.debugging(Debug::INFO) )
{
unideb[Debug::INFO] << myname << "(init): SizeOfMessageQueue=" << SizeOfMessageQueue
<< " MaxCountRemoveOfMessage=" << MaxCountRemoveOfMessage
<< " recvMutexTimeout=" << recvMutexTimeout
<< " pushMutexTimeout=" << pushMutexTimeout
<< endl;
}
}
......@@ -198,7 +200,7 @@ void UniSetObject::setID( UniSetTypes::ObjectId id )
bool UniSetObject::receiveMessage( VoidMessage& vm )
{
{ // lock
uniset_mutex_lock mlk(qmutex, recvMutexTimeout);
uniset_rwmutex_wrlock mlk(qmutex);
if( !queueMsg.empty() )
{
......@@ -374,10 +376,13 @@ void UniSetObject::registered()
throw ORepFailed(err.c_str());
}
if( !oref )
{
unideb[Debug::CRIT] << myname << "(registered): oref is NULL!..." << endl;
return;
UniSetTypes::uniset_rwmutex_rlock lock(refmutex);
if( !oref )
{
unideb[Debug::CRIT] << myname << "(registered): oref is NULL!..." << endl;
return;
}
}
try
......@@ -437,11 +442,14 @@ void UniSetObject::unregister()
return;
}
if( !oref )
{
unideb[Debug::WARN] << myname << "(unregister): oref NULL!" << endl;
reg = false;
return;
UniSetTypes::uniset_rwmutex_rlock lock(refmutex);
if( !oref )
{
unideb[Debug::WARN] << myname << "(unregister): oref NULL!" << endl;
reg = false;
return;
}
}
......@@ -474,16 +482,6 @@ void UniSetObject::termWaiting()
tmr->terminate();
}
// ------------------------------------------------------------------------------------------
void UniSetObject::setRecvMutexTimeout( unsigned long msec )
{
recvMutexTimeout = msec;
}
// ------------------------------------------------------------------------------------------
void UniSetObject::setPushMutexTimeout( unsigned long msec )
{
pushMutexTimeout = msec;
}
// ------------------------------------------------------------------------------------------
void UniSetObject::setThreadPriority( int p )
{
if( thr )
......@@ -493,7 +491,7 @@ void UniSetObject::setThreadPriority( int p )
void UniSetObject::push(const TransportMessage& tm)
{
{ // lock
uniset_mutex_lock mlk(qmutex,pushMutexTimeout);
uniset_rwmutex_wrlock mlk(qmutex);
// контроль переполнения
if( !queueMsg.empty() && queueMsg.size()>SizeOfMessageQueue )
{
......@@ -718,7 +716,7 @@ void UniSetObject::cleanMsgQueue( MessagesQueue& q )
unsigned int UniSetObject::countMessages()
{
{ // lock
uniset_mutex_lock mlk(qmutex, 200);
uniset_rwmutex_rlock mlk(qmutex);
return queueMsg.size();
}
}
......@@ -740,7 +738,7 @@ bool UniSetObject::disactivate()
// Очищаем очередь
{ // lock
uniset_mutex_lock mlk(qmutex, 400);
uniset_rwmutex_wrlock mlk(qmutex);
while( !queueMsg.empty() )
queueMsg.pop();
}
......@@ -765,27 +763,33 @@ bool UniSetObject::disactivate()
unideb[Debug::INFO] << "ok..." << endl;
return true;
}
unideb[Debug::WARN] << "manager already destroyed.." << endl;
if( unideb.debugging(Debug::WARN) )
unideb[Debug::WARN] << "manager already destroyed.." << endl;
}
catch(CORBA::TRANSIENT)
{
unideb[Debug::WARN] << "isExist: нет связи..."<< endl;
if( unideb.debugging(Debug::WARN) )
unideb[Debug::WARN] << "isExist: нет связи..."<< endl;
}
catch( CORBA::SystemException& ex )
{
unideb[Debug::WARN] << "UniSetObject: "<<"поймали CORBA::SystemException: " << ex.NP_minorString() << endl;
if( unideb.debugging(Debug::WARN) )
unideb[Debug::WARN] << "UniSetObject: "<<"поймали CORBA::SystemException: " << ex.NP_minorString() << endl;
}
catch(CORBA::Exception& ex)
{
unideb[Debug::WARN] << "UniSetObject: "<<"поймали CORBA::Exception." << endl;
if( unideb.debugging(Debug::WARN) )
unideb[Debug::WARN] << "UniSetObject: "<<"поймали CORBA::Exception." << endl;
}
catch(Exception& ex)
{
unideb[Debug::WARN] << "UniSetObject: "<< ex << endl;
if( unideb.debugging(Debug::WARN) )
unideb[Debug::WARN] << "UniSetObject: "<< ex << endl;
}
catch(...)
{
unideb[Debug::WARN] << "UniSetObject: "<<" catch ..." << endl;
if( unideb.debugging(Debug::WARN) )
unideb[Debug::WARN] << "UniSetObject: "<<" catch ..." << endl;
}
return false;
......@@ -841,7 +845,10 @@ bool UniSetObject::activate()
oref = poa->servant_to_reference(static_cast<PortableServer::ServantBase*>(this) );
{
UniSetTypes::uniset_rwmutex_wrlock lock(refmutex);
oref = poa->servant_to_reference(static_cast<PortableServer::ServantBase*>(this) );
}
registered();
// Запускаем поток обработки сообщений
......@@ -951,13 +958,13 @@ bool UniSetObject::PriorVMsgCompare::operator()(const UniSetTypes::VoidMessage&
// ------------------------------------------------------------------------------------------
void UniSetObject::setActive( bool set )
{
uniset_mutex_lock l(act_mutex,300);
uniset_rwmutex_wrlock l(mutex_act);
active = set;
}
// ------------------------------------------------------------------------------------------
bool UniSetObject::isActive()
{
uniset_mutex_lock l(act_mutex,200);
uniset_rwmutex_rlock l(mutex_act);
return active;
}
// ------------------------------------------------------------------------------------------
......
src/Processes/IOController.cc
View file @ afa40939
......@@ -45,7 +45,7 @@ IOController::IOController(const string name, const string section):
dioMutex(name+"_dioMutex"),
aioMutex(name+"_aioMutex"),
isPingDBServer(true),
checkLockValuePause(0)
checkLockValuePause(5)
{
}
......@@ -54,7 +54,7 @@ IOController::IOController(ObjectId id):
dioMutex(string(conf->oind->getMapName(id))+"_dioMutex"),
aioMutex(string(conf->oind->getMapName(id))+"_aioMutex"),
isPingDBServer(true),
checkLockValuePause(0)
checkLockValuePause(5)
{
}
......@@ -151,7 +151,7 @@ bool IOController::localGetState( IOController::DIOStateList::iterator& li,
if( li->second.undefined )
throw IOController_i::Undefined();
uniset_spin_lock lock(li->second.val_lock,checkLockValuePause);
uniset_rwmutex_rlock lock(li->second.val_lock,checkLockValuePause);
return li->second.state;
}
......@@ -176,7 +176,7 @@ long IOController::localGetValue( IOController::AIOStateList::iterator& li,
if( li->second.undefined )
throw IOController_i::Undefined();
uniset_spin_lock lock(li->second.val_lock,checkLockValuePause);
uniset_rwmutex_rlock lock(li->second.val_lock,checkLockValuePause);
return li->second.value;
}
......@@ -233,7 +233,7 @@ void IOController::localSetUndefinedState( AIOStateList::iterator& li,
}
{ // lock
uniset_spin_lock lock(li->second.val_lock,checkLockValuePause);
uniset_rwmutex_wrlock lock(li->second.val_lock);
li->second.undefined = undefined;
updateDepends( li->second.dlst, undefined, li->second.dlst_lock );
} // unlock
......@@ -270,7 +270,7 @@ void IOController::localSaveState( IOController::DIOStateList::iterator& li,
}
// { // lock
// uniset_spin_lock lock(li->second.val_lock,checkLockValuePause);
// uniset_rwmutex_lock wrlock(li->second.val_lock,checkLockValuePause);
bool changed = false;
bool blk_set = false;
bool blocked = ( li->second.blocked || li->second.undefined );
......@@ -278,7 +278,7 @@ void IOController::localSaveState( IOController::DIOStateList::iterator& li,
if( checkDFilters(&li->second,state,sup_id) || blocked )
{
{ // lock
uniset_spin_lock lock(li->second.val_lock,checkLockValuePause);
uniset_rwmutex_wrlock lock(li->second.val_lock);
if( !blocked )
li->second.real_state = li->second.state;
......@@ -378,7 +378,7 @@ void IOController::localSaveValue( IOController::AIOStateList::iterator& li,
}
{ // lock
uniset_spin_lock lock(li->second.val_lock,checkLockValuePause);
uniset_rwmutex_wrlock lock(li->second.val_lock);
// фильтрам может потребоваться измениять исходное значение (например для усреднения)
// поэтому передаём (и затем сохраняем) напрямую(ссылку) value (а не const value)
......@@ -500,7 +500,7 @@ void IOController::localSetState( IOController::DIOStateList::iterator& li,
bool blk_set = false;
{ // lock
uniset_spin_lock lock(li->second.val_lock,checkLockValuePause);
uniset_rwmutex_wrlock lock(li->second.val_lock);
blocked = ( li->second.blocked || li->second.undefined );
if ( !blocked )
......@@ -566,7 +566,7 @@ void IOController::localSetValue( IOController::AIOStateList::iterator& li,
if( li!=aioList.end() && li->second.type == UniversalIO::AnalogOutput )
{
{ // lock
uniset_spin_lock lock(li->second.val_lock,checkLockValuePause);
uniset_rwmutex_wrlock lock(li->second.val_lock);
if( li->second.blocked )
li->second.real_value = value;
......@@ -616,7 +616,7 @@ void IOController::dsRegistration( const UniDigitalIOInfo& dinf, bool force )
UniSetTypes::KeyType k = key(dinf.si.id, dinf.si.node);
{ // lock
uniset_mutex_lock lock(dioMutex, 500);
uniset_rwmutex_wrlock lock(dioMutex);
if( !force )
{
DIOStateList::iterator li = dioList.find(k);
......@@ -694,7 +694,7 @@ void IOController::asRegistration( const UniAnalogIOInfo& ainf, bool force )
UniSetTypes::KeyType k = key(ainf.si.id, ainf.si.node);
{ // lock
uniset_mutex_lock lock(aioMutex, 500);
uniset_rwmutex_wrlock lock(aioMutex);
if( !force )
{
AIOStateList::iterator li = aioList.find(k);
......@@ -767,6 +767,7 @@ void IOController::sUnRegistration( const IOController_i::SensorInfo& si )
void IOController::logging( UniSetTypes::SensorMessage& sm )
{
uniset_rwmutex_wrlock l(loggingMutex);
try
{
// struct timezone tz;
......@@ -778,18 +779,16 @@ void IOController::logging( UniSetTypes::SensorMessage& sm )
sm.consumer = dbID;
TransportMessage tm(sm.transport_msg());
{
uniset_mutex_lock l(loggingMutex,300);
ui.send(sm.consumer, tm);
isPingDBServer = true;
}
ui.send(sm.consumer, tm);
isPingDBServer = true;
}
catch(...)
{
if(isPingDBServer)
if( isPingDBServer )
{
unideb[Debug::CRIT] << myname << "(logging): DBServer unavailable" << endl;
isPingDBServer = false;
if( unideb.debugging(Debug::CRIT) )
unideb[Debug::CRIT] << myname << "(logging): DBServer unavailable" << endl;
}
}
}
......@@ -805,7 +804,7 @@ void IOController::dumpToDB()
// uniset_mutex_lock lock(dioMutex, 100);
for( DIOStateList::iterator li = dioList.begin(); li!=dioList.end(); ++li )
{
uniset_spin_lock lock(li->second.val_lock,checkLockValuePause);
uniset_rwmutex_rlock lock(li->second.val_lock,checkLockValuePause);
SensorMessage sm;
sm.id = li->second.si.id;
sm.node = li->second.si.node;
......@@ -826,7 +825,7 @@ void IOController::dumpToDB()
// uniset_mutex_lock lock(aioMutex, 100);
for( AIOStateList::iterator li = aioList.begin(); li!=aioList.end(); ++li )
{
uniset_spin_lock lock(li->second.val_lock,checkLockValuePause);
uniset_rwmutex_rlock lock(li->second.val_lock,checkLockValuePause);
SensorMessage sm;
sm.id = li->second.si.id;
sm.node = li->second.si.node;
......@@ -856,7 +855,7 @@ IOController_i::ASensorInfoSeq* IOController::getAnalogSensorsMap()
int i=0;
for( AIOStateList::iterator it=aioList.begin(); it!=aioList.end(); ++it)
{
uniset_spin_lock lock(it->second.val_lock,checkLockValuePause);
uniset_rwmutex_rlock lock(it->second.val_lock,checkLockValuePause);
(*res)[i] = it->second;
i++;
}
......@@ -877,7 +876,7 @@ IOController_i::DSensorInfoSeq* IOController::getDigitalSensorsMap()
int i=0;
for( DIOStateList::iterator it= dioList.begin(); it!=dioList.end(); ++it)
{
uniset_spin_lock lock(it->second.val_lock,checkLockValuePause);
uniset_rwmutex_rlock lock(it->second.val_lock,checkLockValuePause);
(*res)[i].si = it->second.si;
(*res)[i].type = it->second.type;
(*res)[i].state = it->second.state;
......@@ -934,7 +933,7 @@ IOController_i::DigitalIOInfo IOController::getDInfo(const IOController_i::Senso
DIOStateList::iterator it = dioList.find( key(si.id, si.node) );
if( it!=dioList.end() )
{
uniset_spin_lock lock(it->second.val_lock,checkLockValuePause);
uniset_rwmutex_rlock lock(it->second.val_lock,checkLockValuePause);
return it->second;
}
......@@ -954,7 +953,7 @@ IOController_i::AnalogIOInfo IOController::getAInfo(const IOController_i::Sensor
AIOStateList::iterator it = aioList.find( key(si.id, si.node) );
if( it!=aioList.end() )
{
uniset_spin_lock lock(it->second.val_lock,checkLockValuePause);
uniset_rwmutex_rlock lock(it->second.val_lock,checkLockValuePause);
return it->second;
}
......@@ -1333,7 +1332,7 @@ IOController_i::ASensorInfoSeq* IOController::getSensorSeq( const IDSeq& lst )
DIOStateList::iterator it = dioList.find( UniSetTypes::key(lst[i],conf->getLocalNode()) );
if( it!=dioList.end() )
{
uniset_spin_lock lock(it->second.val_lock,checkLockValuePause);
uniset_rwmutex_rlock lock(it->second.val_lock,checkLockValuePause);
(*res)[i].si = it->second.si;
(*res)[i].type = it->second.type;
(*res)[i].real_value= it->second.real_state ? 1 : 0;
......@@ -1353,7 +1352,7 @@ IOController_i::ASensorInfoSeq* IOController::getSensorSeq( const IDSeq& lst )
AIOStateList::iterator it = aioList.find( UniSetTypes::key(lst[i],conf->getLocalNode()) );
if( it!=aioList.end() )
{
uniset_spin_lock lock(it->second.val_lock,checkLockValuePause);
uniset_rwmutex_rlock lock(it->second.val_lock,checkLockValuePause);
(*res)[i] = it->second;
continue;
}
......@@ -1414,7 +1413,7 @@ IOController_i::ShortIOInfo IOController::getChangedTime( const IOController_i::
if( dit!=dioList.end() )
{
IOController_i::ShortIOInfo i;
uniset_spin_lock lock(dit->second.val_lock,checkLockValuePause);
uniset_rwmutex_rlock lock(dit->second.val_lock,checkLockValuePause);
i.value = dit->second.state ? 1 : 0;
i.tv_sec = dit->second.tv_sec;
i.tv_usec = dit->second.tv_usec;
......@@ -1425,7 +1424,7 @@ IOController_i::ShortIOInfo IOController::getChangedTime( const IOController_i::
if( ait!=aioList.end() )
{
IOController_i::ShortIOInfo i;
uniset_spin_lock lock(ait->second.val_lock,checkLockValuePause);
uniset_rwmutex_rlock lock(ait->second.val_lock,checkLockValuePause);
i.value = ait->second.value;
i.tv_sec = ait->second.tv_sec;
i.tv_usec = ait->second.tv_usec;
......@@ -1452,7 +1451,7 @@ IOController_i::ShortMapSeq* IOController::getSensors()
{
IOController_i::ShortMap m;
{
uniset_spin_lock lock(it->second.val_lock,checkLockValuePause);
uniset_rwmutex_rlock lock(it->second.val_lock,checkLockValuePause);
m.id = it->second.si.id;
m.value = it->second.value;
m.type = it->second.type;
......@@ -1463,7 +1462,7 @@ IOController_i::ShortMapSeq* IOController::getSensors()
{
IOController_i::ShortMap m;
{
uniset_spin_lock lock(it->second.val_lock,checkLockValuePause);
uniset_rwmutex_rlock lock(it->second.val_lock,checkLockValuePause);
m.id = it->second.si.id;
m.value = it->second.state ? 1 : 0;
m.type = it->second.type;
......
src/Processes/IONotifyController.cc
View file @ afa40939
......@@ -226,9 +226,9 @@ void IONotifyController::askState( const IOController_i::SensorInfo& si,
}
{ //lock
uniset_mutex_lock lock(askDMutex, 200);
uniset_rwmutex_wrlock lock(askDMutex);
// а раз есть заносим(исключаем) заказчика
ask( askDIOList, si, ci, cmd);
ask( askDIOList, si, ci, cmd);
} // unlock
// посылка первый раз состояния
......@@ -242,7 +242,7 @@ void IONotifyController::askState( const IOController_i::SensorInfo& si,
smsg.priority = (Message::Priority)li->second.priority;
smsg.supplier = getId();
{
uniset_spin_lock lock(li->second.val_lock,getCheckLockValuePause());
uniset_rwmutex_rlock lock(li->second.val_lock,getCheckLockValuePause());
smsg.state = li->second.state;
smsg.value = li->second.state ? 1:0;
smsg.undefined = li->second.undefined;
......@@ -305,7 +305,7 @@ void IONotifyController::askValue(const IOController_i::SensorInfo& si,
}
{ // lock
uniset_mutex_lock lock(askAMutex, 200);
uniset_rwmutex_wrlock lock(askAMutex);
// а раз есть заносим(исключаем) заказчика
ask( askAIOList, si, ci, cmd);
} // unlock
......@@ -324,7 +324,7 @@ void IONotifyController::askValue(const IOController_i::SensorInfo& si,
smsg.sm_tv_usec = li->second.tv_usec;
smsg.ci = li->second.ci;
{
uniset_spin_lock lock(li->second.val_lock,getCheckLockValuePause());
uniset_rwmutex_rlock lock(li->second.val_lock,getCheckLockValuePause());
smsg.value = li->second.value;
smsg.state = li->second.value ? true:false;
smsg.undefined = li->second.undefined;
......@@ -475,7 +475,7 @@ void IONotifyController::localSaveState( IOController::DIOStateList::iterator& i
// фильтрами или блокировками..
SensorMessage sm(si.id, state);
{ // lock
uniset_spin_lock lock(it->second.val_lock,getCheckLockValuePause());
uniset_rwmutex_rlock lock(it->second.val_lock,getCheckLockValuePause());
if( prevState == it->second.state )
return;
......@@ -494,7 +494,7 @@ void IONotifyController::localSaveState( IOController::DIOStateList::iterator& i
try
{
uniset_mutex_lock l(sig_mutex,500);
uniset_rwmutex_rlock l(sig_mutex);
changeSignal.emit(&sm);
}
catch(...){}
......@@ -509,7 +509,8 @@ void IONotifyController::localSaveState( IOController::DIOStateList::iterator& i
AskMap::iterator it1 = askDIOList.find( key(si.id,si.node) );
if( it1!=askDIOList.end() )
{ // lock
uniset_mutex_lock lock(askDMutex, 1000);
//uniset_mutex_lock lock(askDMutex, 1000);
uniset_rwmutex_rlock lock(askDMutex);
send(it1->second, sm);
} // unlock
}
......@@ -538,7 +539,7 @@ void IONotifyController::localSaveValue( IOController::AIOStateList::iterator& l
// фильтрами или блокировками..
SensorMessage sm(si.id,li->second.value);
{ // lock
uniset_spin_lock lock(li->second.val_lock,getCheckLockValuePause());
uniset_rwmutex_rlock lock(li->second.val_lock,getCheckLockValuePause());
if( prevValue == li->second.value )
return;
......@@ -559,7 +560,8 @@ void IONotifyController::localSaveValue( IOController::AIOStateList::iterator& l
try
{
uniset_mutex_lock l(sig_mutex,500);
//uniset_mutex_rlock l(sig_mutex,500);
uniset_rwmutex_rlock l(sig_mutex);
changeSignal.emit(&sm);
}
catch(...){}
......@@ -574,7 +576,7 @@ void IONotifyController::localSaveValue( IOController::AIOStateList::iterator& l
AskMap::iterator it = askAIOList.find( key(si.id,si.node) );
if( it!=askAIOList.end() )
{ // lock
uniset_mutex_lock lock(askAMutex, 1000);
uniset_rwmutex_rlock lock(askAMutex);
send(it->second, sm);
}
......@@ -759,7 +761,7 @@ void IONotifyController::askThreshold(const IOController_i::SensorInfo& si, cons
CORBA::Long val = localGetValue(li,si);
{ // lock
uniset_mutex_lock lock(trshMutex, 300);
uniset_rwmutex_wrlock lock(trshMutex);
// поиск датчика в списке
UniSetTypes::KeyType skey( key(si.id,si.node) );
......@@ -949,7 +951,7 @@ void IONotifyController::checkThreshold( AIOStateList::iterator& li,
bool send_msg )
{
{ // lock
uniset_mutex_lock lock(trshMutex, 300);
uniset_rwmutex_rlock lock(trshMutex);
// поиск списка порогов
UniSetTypes::KeyType skey( key(si.id,si.node) );
......@@ -973,7 +975,7 @@ void IONotifyController::checkThreshold( AIOStateList::iterator& li,
sm.priority = (Message::Priority)li->second.priority;
sm.ci = li->second.ci;
{
uniset_spin_lock lock(li->second.val_lock,getCheckLockValuePause());
uniset_rwmutex_rlock lock(li->second.val_lock,getCheckLockValuePause());
sm.value = li->second.value;
sm.state = li->second.value!=0 ? true:false;
sm.undefined = li->second.undefined;
......@@ -1096,7 +1098,7 @@ void IONotifyController::askOutput(const IOController_i::SensorInfo& si,
{
case UniversalIO::DigitalOutput:
{ //lock
uniset_mutex_lock lock(askDOMutex, 200);
uniset_rwmutex_wrlock lock(askDOMutex);
// а раз есть заносим(исключаем) заказчика
ask( askDOList, si, ci, cmd );
} // unlock
......@@ -1104,7 +1106,7 @@ void IONotifyController::askOutput(const IOController_i::SensorInfo& si,
case UniversalIO::AnalogOutput:
{ //lock
uniset_mutex_lock lock(askAOMutex, 200);
uniset_rwmutex_wrlock lock(askAOMutex);
// а раз есть заносим(исключаем) заказчика
ask( askAOList, si, ci, cmd );
} // unlock
......@@ -1189,7 +1191,7 @@ void IONotifyController::localSetState( IOController::DIOStateList::iterator& it
// Рассылаем уведомления только если значение изменилось...
SensorMessage sm(si.id, state);
{ // lock
uniset_spin_lock lock(it->second.val_lock,getCheckLockValuePause());
uniset_rwmutex_rlock lock(it->second.val_lock,getCheckLockValuePause());
if( prevState == it->second.state )
return;
sm.id = si.id;
......@@ -1206,7 +1208,7 @@ void IONotifyController::localSetState( IOController::DIOStateList::iterator& it
try
{
uniset_mutex_lock l(sig_mutex,500);
uniset_rwmutex_rlock l(sig_mutex);
changeSignal.emit(&sm);
}
catch(...){}
......@@ -1222,7 +1224,7 @@ void IONotifyController::localSetState( IOController::DIOStateList::iterator& it
AskMap::iterator ait = askDOList.find( UniSetTypes::key(si.id,si.node) );
if( ait!=askDOList.end() )
{ // lock
uniset_mutex_lock lock(askDMutex, 200);
uniset_rwmutex_rlock lock(askDMutex);
send(ait->second, sm);
} // unlock
}
......@@ -1245,7 +1247,7 @@ void IONotifyController::localSetValue( IOController::AIOStateList::iterator& li
// Рассылаем уведомления только если значение изменилось...
SensorMessage sm;
{ // lock
uniset_spin_lock lock(li->second.val_lock,getCheckLockValuePause());
uniset_rwmutex_rlock lock(li->second.val_lock,getCheckLockValuePause());
if( prevValue == li->second.value )
return;
......@@ -1264,7 +1266,7 @@ void IONotifyController::localSetValue( IOController::AIOStateList::iterator& li
try
{
uniset_mutex_lock l(sig_mutex,500);
uniset_rwmutex_rlock l(sig_mutex);
changeSignal.emit(&sm);
}
catch(...){}
......@@ -1279,7 +1281,7 @@ void IONotifyController::localSetValue( IOController::AIOStateList::iterator& li
AskMap::iterator dit = askAOList.find( UniSetTypes::key(si.id,si.node) );
if( dit!=askAOList.end() )
{ // lock
uniset_mutex_lock lock(askAMutex, 200);
uniset_rwmutex_rlock lock(askAMutex);
send(dit->second, sm);
}
......@@ -1296,7 +1298,7 @@ void IONotifyController::localSetValue( IOController::AIOStateList::iterator& li
IONotifyController::ThresholdExtList::iterator IONotifyController::findThreshold( UniSetTypes::KeyType key, UniSetTypes::ThresholdId tid )
{
{ // lock
uniset_mutex_lock lock(trshMutex, 300);
uniset_rwmutex_rlock lock(trshMutex);
// поиск списка порогов
// UniSetTypes::KeyType skey( key(si.id,si.node) );
AskThresholdMap::iterator lst = askTMap.find(key);
......@@ -1416,7 +1418,7 @@ void IONotifyController::onChangeUndefined( DependsList::iterator it, bool undef
AskMap::iterator it1 = askDIOList.find( key(it->si.id,it->si.node) );
if( it1!=askDIOList.end() )
{ // lock
uniset_mutex_lock lock(askDMutex, 1000);
uniset_rwmutex_rlock lock(askDMutex);
send(it1->second, sm);
} // unlock
}
......
src/Timers/PassiveSysTimer.cc
View file @ afa40939
......@@ -28,7 +28,6 @@
#include <pthread.h>
#include <time.h>
#include "PosixThread.h"
#include "PassiveTimer.h"
// ------------------------------------------------------------------------------------------
......
src/Various/LT_Object.cc
View file @ afa40939
......@@ -33,6 +33,7 @@ using namespace UniSetTypes;
// -----------------------------------------------------------------------------
LT_Object::LT_Object():
lstMutex("LT_Object::lstMutex"),
sleepTime(UniSetTimer::WaitUpTime)
{
tmLast.setTiming(UniSetTimer::WaitUpTime);
......@@ -48,7 +49,7 @@ timeout_t LT_Object::checkTimers( UniSetObject* obj )
try
{
{ // lock
uniset_mutex_lock lock(lstMutex, 5000);
uniset_rwmutex_rlock lock(lstMutex, 5000);
if( tlst.empty() )
{
......@@ -70,7 +71,7 @@ timeout_t LT_Object::checkTimers( UniSetObject* obj )
}
{ // lock
uniset_mutex_lock lock(lstMutex, 5000);
uniset_rwmutex_wrlock lock(lstMutex);
sleepTime = UniSetTimer::WaitUpTime;
for( TimersList::iterator li=tlst.begin();li!=tlst.end();++li)
{
......@@ -130,10 +131,7 @@ timeout_t LT_Object::askTimer( UniSetTypes::TimerId timerid, timeout_t timeMS, c
}
{ // lock
if( unideb.debugging(Debug::INFO) && !lstMutex.isRelease() )
unideb[Debug::INFO] << "(LT_askTimer): придется подождать освобождения lstMutex-а" << endl;
uniset_mutex_lock lock(lstMutex, 2000);
uniset_rwmutex_wrlock lock(lstMutex);
// поищем а может уж такой есть
if( !tlst.empty() )
{
......@@ -166,20 +164,13 @@ timeout_t LT_Object::askTimer( UniSetTypes::TimerId timerid, timeout_t timeMS, c
if( unideb.debugging(Debug::INFO) )
unideb[Debug::INFO] << "(LT_askTimer): поступил отказ по таймеру id="<< timerid << endl;
{ // lock
if( unideb.debugging(Debug::INFO) && !lstMutex.isRelease() )
unideb[Debug::INFO] << "(LT_askTimer): придется подождать освобождения lstMutex-а\n";
uniset_mutex_lock lock(lstMutex, 2000);
uniset_rwmutex_wrlock lock(lstMutex);
tlst.remove_if(Timer_eq(timerid)); // STL - способ
} // unlock
}
{ // lock
if( unideb.debugging(Debug::INFO) && !lstMutex.isRelease() )
unideb[Debug::INFO] << "(LT_askTimer): придется подождать освобождения lstMutex-а\n";
uniset_mutex_lock lock(lstMutex, 2000);
uniset_rwmutex_rlock lock(lstMutex);
if( tlst.empty() )
sleepTime = UniSetTimer::WaitUpTime;
......
src/Various/Mutex.cc
View file @ afa40939
......@@ -31,6 +31,8 @@
using namespace std;
using namespace UniSetTypes;
// -----------------------------------------------------------------------------
#define MUTEX_DEBUG(m) {}
uniset_mutex::uniset_mutex():
cnd(0),
nm(""),
......@@ -52,15 +54,23 @@ uniset_mutex::~uniset_mutex()
delete cnd;
}
// -----------------------------------------------------------------------------
std::ostream& UniSetTypes::operator<<(std::ostream& os, uniset_mutex& m )
{
return os << m.name();
}
// -----------------------------------------------------------------------------
void uniset_mutex::lock()
{
sem.wait();
locked = 1;
MUTEX_DEBUG(cerr << nm << " Locked.." << endl;)
}
// -----------------------------------------------------------------------------
void uniset_mutex::unlock()
{
locked = 0;
MUTEX_DEBUG(cerr << nm << " Unlocked.." << endl;)
sem.post();
cnd->signal();
}
......@@ -138,16 +148,29 @@ uniset_mutex_lock& uniset_mutex_lock::operator=(const uniset_mutex_lock &r)
return *this;
}
// -----------------------------------------------------------------------------
uniset_spin_mutex::uniset_spin_mutex():
uniset_rwmutex::uniset_rwmutex( const std::string& name ):
nm(name),
wr_wait(0)
{
}
uniset_rwmutex::uniset_rwmutex():
wr_wait(0)
{
}
uniset_rwmutex::~uniset_rwmutex()
{
}
uniset_spin_mutex::~uniset_spin_mutex()
std::ostream& UniSetTypes::operator<<(std::ostream& os, uniset_rwmutex& m )
{
return os << m.name();
}
const uniset_spin_mutex &uniset_spin_mutex::operator=( const uniset_spin_mutex& r )
const uniset_rwmutex &uniset_rwmutex::operator=( const uniset_rwmutex& r )
{
if( this != &r )
unlock();
......@@ -155,12 +178,12 @@ const uniset_spin_mutex &uniset_spin_mutex::operator=( const uniset_spin_mutex&
return *this;
}
uniset_spin_mutex::uniset_spin_mutex( const uniset_spin_mutex& r )
uniset_rwmutex::uniset_rwmutex( const uniset_rwmutex& r )
{
//unlock();
}
void uniset_spin_mutex::lock( int check_pause_msec )
void uniset_rwmutex::lock( int check_pause_msec )
{
wr_wait += 1;
while( !m.tryWriteLock() )
......@@ -169,8 +192,9 @@ void uniset_spin_mutex::lock( int check_pause_msec )
msleep(check_pause_msec);
}
wr_wait -= 1;
MUTEX_DEBUG(cerr << nm << " Locked.." << endl;)
}
void uniset_spin_mutex::wrlock( int check_pause_msec )
void uniset_rwmutex::wrlock( int check_pause_msec )
{
wr_wait += 1;
while( !m.tryWriteLock() )
......@@ -179,8 +203,9 @@ void uniset_spin_mutex::wrlock( int check_pause_msec )
msleep(check_pause_msec);
}
wr_wait -= 1;
MUTEX_DEBUG(cerr << nm << " WRLocked.." << endl;)
}
void uniset_spin_mutex::rlock( int check_pause_msec )
void uniset_rwmutex::rlock( int check_pause_msec )
{
while( wr_wait > 0 )
msleep(check_pause_msec);
......@@ -190,42 +215,34 @@ void uniset_spin_mutex::rlock( int check_pause_msec )
if( check_pause_msec > 0 )
msleep(check_pause_msec);
}
}
void uniset_spin_mutex::unlock()
{
m.unlock();
}
// -------------------------------------------------------------------------------------------
uniset_spin_lock::uniset_spin_lock( uniset_spin_mutex& _m, int check_pause_msec ):
m(_m)
{
m.lock(check_pause_msec);
MUTEX_DEBUG(cerr << nm << " RLocked.." << endl;)
}
uniset_spin_lock::~uniset_spin_lock()
void uniset_rwmutex::unlock()
{
m.unlock();
MUTEX_DEBUG(cerr << nm << " Unlocked.." << endl;)
}
uniset_spin_wrlock::uniset_spin_wrlock( uniset_spin_mutex& _m, int check_pause_msec ):
uniset_spin_lock(_m)
// -------------------------------------------------------------------------------------------
uniset_rwmutex_wrlock::uniset_rwmutex_wrlock( uniset_rwmutex& _m, int check_pause_msec ):
m(_m)
{
m.wrlock(check_pause_msec);
}
uniset_spin_wrlock::~uniset_spin_wrlock()
uniset_rwmutex_wrlock::~uniset_rwmutex_wrlock()
{
// unlocked in uniset_spin_lock destructor
m.unlock();
}
uniset_spin_wrlock::uniset_spin_wrlock( const uniset_spin_wrlock& r ):
uniset_spin_lock(r.m)
uniset_rwmutex_wrlock::uniset_rwmutex_wrlock( const uniset_rwmutex_wrlock& r ):
m(r.m)
{
}
uniset_spin_wrlock& uniset_spin_wrlock::operator=(const uniset_spin_wrlock& r)
uniset_rwmutex_wrlock& uniset_rwmutex_wrlock::operator=(const uniset_rwmutex_wrlock& r)
{
if( this != &r )
m = r.m;
......@@ -233,31 +250,28 @@ uniset_spin_wrlock& uniset_spin_wrlock::operator=(const uniset_spin_wrlock& r)
return *this;
}
// -------------------------------------------------------------------------------------------
uniset_spin_rlock::uniset_spin_rlock( uniset_spin_mutex& _m, int check_pause_msec ):
uniset_spin_lock(_m)
uniset_rwmutex_rlock::uniset_rwmutex_rlock( uniset_rwmutex& _m, int check_pause_msec ):
m(_m)
{
m.rlock(check_pause_msec);
}
uniset_spin_rlock::~uniset_spin_rlock()
uniset_rwmutex_rlock::~uniset_rwmutex_rlock()
{
// unlocked in uniset_spin_lock destructor
m.unlock();
}
uniset_spin_rlock::uniset_spin_rlock( const uniset_spin_rlock& r ):
uniset_spin_lock(r.m)
uniset_rwmutex_rlock::uniset_rwmutex_rlock( const uniset_rwmutex_rlock& r ):
m(r.m)
{
}
uniset_spin_rlock& uniset_spin_rlock::operator=(const uniset_spin_rlock& r)
uniset_rwmutex_rlock& uniset_rwmutex_rlock::operator=(const uniset_rwmutex_rlock& r)
{
if( this != &r )
m = r.m;
return *this;
}
// -----------------------------------------------------------------------------
#undef MUTEX_LOCK_SLEEP_MS
// -----------------------------------------------------------------------------
tests/threadtst.cc 0 → 100644
View file @ afa40939
#include <string>
#include <sstream>
#include "Mutex.h"
#include "ThreadCreator.h"
#include "UniSetTypes.h"
#include "modbus/TCPCheck.h"
using namespace std;
using namespace UniSetTypes;
const string ip1="localhost:2049";
const string ip2="localhost:2048";
const string ip3="192.168.77.11:2049";
uniset_mutex m;
class MyClass
{
public:
MyClass( const std::string& name ): nm(name)
{
thr = new ThreadCreator<MyClass>(this, &MyClass::thread);
}
~MyClass()
{
delete thr;
}
inline cctid_t start(){ return thr->start(); }
inline void stop(){ thr->stop(); }
inline pid_t getTID(){ return thr->getTID(); }
// BAD code...only for tests
inline ThreadCreator<MyClass>* mythr(){ return thr; }
protected:
std::string nm;
void thread()
{
cout << nm << ": start thread (" << getTID() << ")" << endl;
while(1)
{
ost::Thread::sleep(10000);
}
cout << nm << ": finish thread (" << getTID() << ")" << endl;
}
private:
ThreadCreator<MyClass>* thr;
};
class MyClass2
{
public:
MyClass2( const std::string& name ): nm(name)
{
thr = new ThreadCreator<MyClass2>(this, &MyClass2::thread);
}
~MyClass2(){ delete thr; }
inline cctid_t start(){ return thr->start(); }
inline void stop(){ thr->stop(); }
inline pid_t getTID(){ return thr->getTID(); }
protected:
std::string nm;
TCPCheck tcp;
void thread()
{
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
cout << nm << ": start thread (" << getTID() << ")" << endl;
while(1)
{
cout << nm << " check " << ip1 << ": " << ( tcp.check(ip1,300,100) ? "OK" : "FAIL" ) << endl;
pthread_testcancel();
cout << nm << " check " << ip2 << ": " << ( tcp.check(ip2,300,100) ? "OK" : "FAIL" ) << endl;
pthread_testcancel();
cout << nm << " check " << ip3 << ": " << ( tcp.check(ip3,300,100) ? "OK" : "FAIL" ) << endl;
pthread_testcancel();
cout << nm << " msleep 2000" << endl;
ost::Thread::sleep(2000);
pthread_testcancel();
}
cout << nm << ": finish thread (" << getTID() << ")" << endl;
}
private:
ThreadCreator<MyClass2>* thr;
};
int main( int argc, const char **argv )
{
try
{
MyClass t1("Thread1");
cout << "start1..." << endl;
t1.start();
msleep(30);
cout << "TID: " << t1.getTID() << endl;
msleep(500);
cout << "stop1..." << endl;
t1.stop();
msleep(100);
cout << "start2..." << endl;
t1.start();
int prior = t1.mythr()->getPriority();
cout << "priority: " << prior << endl;
cout << "set prior +1 [" << prior++ << "]" << endl;
t1.mythr()->setPriority(prior);
cout << "check priority: " << t1.mythr()->getPriority() << endl;
prior=-2;
cout << "set prior -2 " << endl;
cout << "retcode=" << t1.mythr()->setPriority(prior) << endl;
cout << "check priority: " << t1.mythr()->getPriority() << endl;
msleep(500);
// cout << "kill2..." << endl;
// t1.kill(SIGUSR1);
// msleep(100);
// cout << "start3..." << endl;
// t1.start();
// pause();
cout << "finished3..." << endl;
TCPCheck tcp;
cout << "check " << ip1 << ": " << ( tcp.check(ip1,300,100) ? "OK" : "FAIL" ) << endl;
cout << "check " << ip2 << ": " << ( tcp.check(ip2,300,100) ? "OK" : "FAIL" ) << endl;
cout << "check " << ip3 << ": " << ( tcp.check(ip3,300,100) ? "OK" : "FAIL" ) << endl;
msleep(50);
cout << "check finished..." << endl;
// поток в потоке..
MyClass2 t2("Thread2");
cout << "thread2 start..." << endl;
t2.start();
msleep(6000);
cout << "thread2 stop..." << endl;
t2.stop();
}
catch( std::exception& ex )
{
cerr << "catch: " << ex.what() << endl;
}
return 0;
}
tests/umutex.cc
View file @ afa40939
......@@ -9,7 +9,7 @@ using namespace std;
using namespace UniSetTypes;
uniset_mutex m;
uniset_spin_mutex m_spin;
uniset_rwmutex m_spin;
class MyClass
{
......@@ -89,7 +89,7 @@ class MyClassSpin
if( !readLock )
{
// cerr << nm << ": before RWlock.." << endl;
uniset_spin_lock l(m_spin,5);
uniset_rwmutex_wrlock l(m_spin,5);
count++;
msleep(30);
// cerr << nm << ": after RWlock.." << endl;
......@@ -97,7 +97,7 @@ class MyClassSpin
else
{
// cerr << nm << "(readLock): before lock.." << endl;
uniset_spin_rlock l(m_spin);
uniset_rwmutex_rlock l(m_spin);
count++;
msleep(20);
// cerr << nm << "(readLock): after lock.." << endl;
......@@ -160,8 +160,8 @@ int main( int argc, const char **argv )
cerr << "test write lock: " << (check_wr_lock(m) ? "FAIL" : "OK [0]") << endl;
cerr << "test read lock: " << (check_r_lock(m) ? "FAIL" : "OK [0]") << endl;
cerr << endl << "***** uniset_spin_mutex ***" << endl;
uniset_spin_mutex m1;
cerr << endl << "***** uniset_rwmutex ***" << endl;
uniset_rwmutex m1;
cout << "read lock.." << endl;
m1.rlock();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment