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

conf/test.xml

@@ -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

@@ -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

@@ -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

@@ -204,7 +204,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 )
 		{
@@ -235,7 +235,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

@@ -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

@@ -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

@@ -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;
 }
 // -----------------------------------------------------------------------------
@@ -2413,7 +2415,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);
@@ -2507,7 +2509,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

@@ -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

@@ -5,18 +5,8 @@
 #include <string>
 #include <map>
 #include <vector>
-#include "IONotifyController.h"
-#include "UniSetObject_LT.h"
+#include "MBExchange.h"
 #include "modbus/ModbusTCPMaster.h"
-#include "PassiveTimer.h"
-#include "Trigger.h"
-#include "Mutex.h"
-#include "Calibration.h"
-#include "SMInterface.h"
-#include "SharedMemory.h"
-#include "IOBase.h"
-#include "VTypes.h"
-#include "MTR.h"
 // -----------------------------------------------------------------------------
 /*!
       \page page_ModbusTCP Реализация ModbusTCP master
@@ -24,6 +14,7 @@
       - \ref sec_MBTCP_Comm
       - \ref sec_MBTCP_Conf
       - \ref sec_MBTCP_ConfList
+	  - \ref sec_MBTCP_ExchangeMode
 
       \section sec_MBTCP_Comm Общее описание ModbusTCP master
       Класс реализует процесс обмена (опрос/запись) с RTU-устройствами,
@@ -53,6 +44,7 @@
       - \b timeout msec - таймаут, для определения отсутствия связи
       - \b invert - инвертировать логику. По умолчанию датчик выставляется в "1" при \b наличии связи.
       - \b respondSensor - идентификатор датчика связи.
+      - \b modeSensor - идентификатор датчика режима работы (см. MBExchange::ExchangeMode).
 	  - \b ask_every_reg - 1 - опрашивать ВСЕ регистры подряд, не обращая внимания на timeout. По умолчанию - "0" Т.е. опрос устройства (на текущем шаге цикла опроса), прерывается на первом же регистре, при опросе которого возникнет timeout.
 
       \par Параметры запуска
@@ -69,10 +61,11 @@
       Порт задаётся в конфигурационном файле параметром \b gateway_port или
       параметром командной строки \b --xxx-gateway-port. По умолчанию используется порт \b 502.
 
-      \b --xxx-recv-timeout или \b recv_timeout msec - таймаут на приём сообщений. По умолчанию 2000 мсек.
+      \b --xxx-recv-timeout или \b recv_timeout msec - таймаут на приём одного сообщения. По умолчанию 100 мсек.
 
-      \b --xxx-all-timeout или \b all_timeout msec  - таймаут на определение отсутсвия связи
+      \b --xxx-timeout или \b timeout msec  - таймаут на определение отсутсвия связи
                                                    (после этого идёт попытка реинициализировать соединение)
+                                                   По умолчанию 5000 мсек.
 
       \b --xxx-no-query-optimization или \b no_query_optimization   - [1|0] отключить оптимизацию запросов
 
@@ -167,17 +160,36 @@
 
    При этом будет записывыться значение "default".
 
-
    \warning Регистр должен быть уникальным. И может повторятся только если указан параметр \a nbit или \a nbyte.
 
+
+	\section sec_MBTCP_ExchangeMode Управление режимом работы MBTCPMaster
+		В MBTCPMaster заложена возможность управлять режимом работы процесса. Поддерживаются
+	следующие режимы:
+	- \b emNone - нормальная работа (по умолчанию)
+    - \b emWriteOnly - "только посылка данных" (работают только write-функции)
+	- \b emReadOnly - "только чтение" (работают только read-функции)
+	- \b emSkipSaveToSM - "не записывать данные в SM", это особый режим, похожий на \b emWriteOnly,
+			но отличие в том, что при этом режиме ведётся полноценый обмен (и read и write),
+	только реально данные не записываются в SharedMemory(SM).
+	- \b emSkipExchnage - отключить обмен (при этом данные "из SM" обновляются).
+
+	Режимы переключаются при помощи датчика, который можно задать либо аргументом командной строки
+	\b --prefix-exchange-mode-id либо в конф. файле параметром \b echangeModeID="". Константы определяющие режимы объявлены в MBTCPMaster::ExchangeMode.
+
 */
 // -----------------------------------------------------------------------------
 /*!
-	Реализация Modbus TCP Master для обмена с многими ModbusRTU устройствами
+	\par Реализация Modbus TCP Master для обмена с многими ModbusRTU устройствами
 	через один modbus tcp шлюз.
+
+	\par Чтобы не зависеть от таймаутов TCP соединений, которые могут неопределённо зависать
+	на создании соединения с недоступным хостом. Обмен вынесен в отдельный поток.
+	При этом в этом же потоке обновляются данные в SM. В свою очередь информация о датчиках
+	связи обновляется в основном потоке (чтобы не зависеть от TCP).
 */
 class MBTCPMaster:
-	public UniSetObject_LT
+	public MBExchange
 {
 	public:
 		MBTCPMaster( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
@@ -192,258 +204,30 @@ class MBTCPMaster:
 		/*! глобальная функция для вывода help-а */
 		static void help_print( int argc, const char* const* argv );
 
-		void execute();
-
-		static const int NoSafetyState=-1;
-
-		enum Timer
-		{
-			tmExchange
-		};
-
-		enum DeviceType
-		{
-			dtUnknown,		/*!< неизвестный */
-			dtRTU,			/*!< RTU (default) */
-			dtMTR			/*!< MTR (DEIF) */
-		};
-
-		static DeviceType getDeviceType( const std::string dtype );
-		friend std::ostream& operator<<( std::ostream& os, const DeviceType& dt );
-// -------------------------------------------------------------------------------
-		struct RTUDevice;
-		struct RegInfo;
-
-		struct RSProperty:
-			public IOBase
-		{
-			// only for RTU
-			short nbit;				/*!< bit number) */
-			VTypes::VType vType;	/*!< type of value */
-			short rnum;				/*!< count of registers */
-			short nbyte;			/*!< byte number (1-2) */
-
-			RSProperty():
-				nbit(-1),vType(VTypes::vtUnknown),
-				rnum(VTypes::wsize(VTypes::vtUnknown)),
-				nbyte(0),reg(0)
-			{}
-
-			RegInfo* reg;
-		};
-
-		friend std::ostream& operator<<( std::ostream& os, const RSProperty& p );
-
-		typedef std::list<RSProperty> PList;
-		static std::ostream& print_plist( std::ostream& os, PList& p );
-
-		typedef unsigned long RegID;
-
-		typedef std::map<RegID,RegInfo*> RegMap;
-		struct RegInfo
-		{
-			RegInfo():
-				mbval(0),mbreg(0),mbfunc(ModbusRTU::fnUnknown),
-				id(0),dev(0),mtrType(MTR::mtUnknown),
-				q_num(0),q_count(1),mb_initOK(true),sm_initOK(true)
-			{}
-
-			ModbusRTU::ModbusData mbval;
-			ModbusRTU::ModbusData mbreg;			/*!< регистр */
-			ModbusRTU::SlaveFunctionCode mbfunc;	/*!< функция для чтения/записи */
-			PList slst;
-			RegID id;
-
-			RTUDevice* dev;
-
-			// only for MTR
-			MTR::MTRType mtrType;	/*!< тип регистра (согласно спецификации на MTR) */
-
-			// optimization
-			int q_num;		/*!< number in query */
-			int q_count;	/*!< count registers for query */
-
-			RegMap::iterator rit;
-
-			// начальная инициалиазция для "записываемых" регистров
-			// Механизм:
-			// Если tcp_preinit="1", то сперва будет сделано чтение значения из устройства.
-			// при этом флаг mb_init=false пока не пройдёт успешной инициализации
-			// Если tcp_preinit="0", то флаг mb_init сразу выставляется в true.
-			bool mb_initOK;	/*!< инициализировалось ли значение из устройства */
-
-			// Флаг sm_init означает, что писать в устройство нельзя, т.к. значение в "карте регистров"
-			// ещё не инициализировано из SM
-			bool sm_initOK;	/*!< инициализировалось ли значение из SM */
-		};
-
-		friend std::ostream& operator<<( std::ostream& os, RegInfo& r );
-
-		struct RTUDevice
-		{
-			RTUDevice():
-			respnond(false),
-			mbaddr(0),
-			dtype(dtUnknown),
-			resp_id(UniSetTypes::DefaultObjectId),
-			resp_state(false),
-			resp_invert(false),
-			resp_real(false),
-			resp_init(false),
-			ask_every_reg(false)
-			{
-				resp_trTimeout.change(false);
-			}
-
-			bool respnond;
-			ModbusRTU::ModbusAddr mbaddr;	/*!< адрес устройства */
-			RegMap regmap;
-
-			DeviceType dtype;	/*!< тип устройства */
-
-			UniSetTypes::ObjectId resp_id;
-			IOController::DIOStateList::iterator resp_dit;
-			PassiveTimer resp_ptTimeout;
-			Trigger resp_trTimeout;
-			bool resp_state;
-			bool resp_invert;
-			bool resp_real;
-			bool resp_init;
-			bool ask_every_reg;
-
-			// return TRUE if state changed
-			bool checkRespond();
-
-		};
-
-		friend std::ostream& operator<<( std::ostream& os, RTUDevice& d );
-
-		typedef std::map<ModbusRTU::ModbusAddr,RTUDevice*> RTUDeviceMap;
-
-		friend std::ostream& operator<<( std::ostream& os, RTUDeviceMap& d );
-		void printMap(RTUDeviceMap& d);
-// ----------------------------------
-		static RegID genRegID( const ModbusRTU::ModbusData r, const int fn );
-
-
 	protected:
-		struct InitRegInfo
-		{
-			InitRegInfo():
-			dev(0),mbreg(0),
-			mbfunc(ModbusRTU::fnUnknown),
-			initOK(false),ri(0)
-			{}
-			RSProperty p;
-			RTUDevice* dev;
-			ModbusRTU::ModbusData mbreg;
-			ModbusRTU::SlaveFunctionCode mbfunc;
-			bool initOK;
-			RegInfo* ri;
-		};
-		typedef std::list<InitRegInfo> InitList;
-
-		void firstInitRegisters();
-		bool preInitRead( InitList::iterator& p );
-		bool initSMValue( ModbusRTU::ModbusData* data, int count, RSProperty* p );
-		bool allInitOK;
-
-		RTUDeviceMap rmap;
-		InitList initRegList;	/*!< список регистров для инициализации */
-
-		ModbusTCPMaster* mb;
-		UniSetTypes::uniset_mutex mbMutex;
+		virtual void sysCommand( UniSetTypes::SystemMessage *sm );
+
+		UniSetTypes::uniset_rwmutex mbMutex;
 		std::string iaddr;
 //		ost::InetAddress* ia;
 		int port;
 		int recv_timeout;
 
-		xmlNode* cnode;
-		std::string s_field;
-		std::string s_fvalue;
-
-		SMInterface* shm;
-
-		void step();
-		void poll();
-		bool pollRTU( RTUDevice* dev, RegMap::iterator& it );
-
-		void updateSM();
-		void updateRTU(RegMap::iterator& it);
-		void updateMTR(RegMap::iterator& it);
-		void updateRSProperty( RSProperty* p, bool write_only=false );
-
-		virtual void processingMessage( UniSetTypes::VoidMessage *msg );
-		void sysCommand( UniSetTypes::SystemMessage *msg );
-		void sensorInfo( UniSetTypes::SensorMessage*sm );
-		void timerInfo( UniSetTypes::TimerMessage *tm );
-		void askSensors( UniversalIO::UIOCommand cmd );
-		void initOutput();
-		void waitSMReady();
-
-		virtual bool activateObject();
-
-		// действия при завершении работы
-		virtual void sigterm( int signo );
-
-		void initMB( bool reopen=false );
-		void initIterators();
-		bool initItem( UniXML_iterator& it );
-		bool readItem( UniXML& xml, UniXML_iterator& it, xmlNode* sec );
-		void initDeviceList();
-		void initOffsetList();
-
-		RTUDevice* addDev( RTUDeviceMap& dmap, ModbusRTU::ModbusAddr a, UniXML_iterator& it );
-		RegInfo* addReg( RegMap& rmap, RegID id, ModbusRTU::ModbusData r, UniXML_iterator& it,
-							RTUDevice* dev, RegInfo* rcopy=0 );
-		RSProperty* addProp( PList& plist, RSProperty& p );
-
-		bool initMTRitem( UniXML_iterator& it, RegInfo* p );
-		bool initRSProperty( RSProperty& p, UniXML_iterator& it );
-		bool initRegInfo( RegInfo* r, UniXML_iterator& it, RTUDevice* dev  );
-		bool initRTUDevice( RTUDevice* d, UniXML_iterator& it );
-		bool initDeviceInfo( RTUDeviceMap& m, ModbusRTU::ModbusAddr a, UniXML_iterator& it );
-
-		void rtuQueryOptimization( RTUDeviceMap& m );
-
-		void readConfiguration();
+//		virtual void step();
+		virtual ModbusClient* initMB( bool reopen=false );
 
+		void poll_thread();
+		bool force_disconnect;
 
 	 private:
 		MBTCPMaster();
-		bool initPause;
-		UniSetTypes::uniset_mutex mutex_start;
-
-		bool force;		/*!< флаг означающий, что надо сохранять в SM, даже если значение не менялось */
-		bool force_out;	/*!< флаг означающий, принудительного чтения выходов */
-		bool mbregFromID;
-		int polltime;	/*!< переодичность обновления данных, [мсек] */
-		timeout_t sleepPause_usec;
-
-		PassiveTimer ptHeartBeat;
-		UniSetTypes::ObjectId sidHeartBeat;
-		int maxHeartBeat;
-		IOController::AIOStateList::iterator aitHeartBeat;
-		UniSetTypes::ObjectId test_id;
-
-		UniSetTypes::uniset_mutex pollMutex;
-
-		bool activated;
-		int activateTimeout;
-
-		bool noQueryOptimization;
-		bool force_disconnect;
-
-		bool allNotRespond;
-		Trigger trAllNotRespond;
-		PassiveTimer ptAllNotRespond;
-		std::string prefix;
 
-		bool no_extimer;
+		ModbusTCPMaster* mbtcp;
 
-		timeout_t stat_time; 		/*!< время сбора статистики обмена */
-		int poll_count;
-		PassiveTimer ptStatistic;   /*!< таймер для сбора статистики обмена */
+		// т.к. TCP может "зависнуть" на подключении к недоступному узлу
+		// делаем опрос в отдельном потоке
+		ThreadCreator<MBTCPMaster>* pollThread; /*!< поток опроса */
+		UniSetTypes::uniset_rwmutex tcpMutex;
 };
 // -----------------------------------------------------------------------------
 #endif // _MBTCPMaster_H_

extensions/ModbusMaster/MBTCPMultiMaster.h

@@ -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

@@ -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

@@ -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/RRDServer/Makefile.am

@@ -6,7 +6,7 @@ bin_PROGRAMS = @PACKAGE@-rrdserver
 
 RRD_VER=@LIBVER@
 
-lib_LTLIBRARIES 			= libUniSetRRDServer.la
+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 \

extensions/RRDServer/start_fg.sh

 #!/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

@@ -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

@@ -361,7 +361,7 @@ class SharedMemory:
 		void buildEventList( xmlNode* cnode );
 		void readEventList( std::string oname );
 		
-		UniSetTypes::uniset_mutex mutex_start;
+		UniSetTypes::uniset_rwmutex mutex_start;
 		
 		struct HeartBeatInfo
 		{
@@ -437,7 +437,7 @@ class SharedMemory:
 		
 		UniSetTypes::uniset_mutex act_mutex;
 
-		UniSetTypes::uniset_mutex act_mutex;
+		UniSetTypes::uniset_rwmutex mutex_act;
 
 	private:
 		HistorySlot m_historySignal;

extensions/UNetUDP/UNetExchange.cc

@@ -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

@@ -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

@@ -91,6 +91,7 @@ UNetReceiver::~UNetReceiver()
 // -----------------------------------------------------------------------------
 void UNetReceiver::setReceiveTimeout( timeout_t msec )
 {
+	uniset_rwmutex_wrlock l(tmMutex);
 	recvTimeout = msec;
 	ptRecvTimeout.setTiming(msec);
 }
@@ -142,7 +143,7 @@ void UNetReceiver::setLostPacketsID( UniSetTypes::ObjectId id )
 // -----------------------------------------------------------------------------
 void UNetReceiver::setLockUpdate( bool st )
 {
-	uniset_mutex_lock l(lockMutex,200);
+	uniset_rwmutex_wrlock l(lockMutex);
 	lockUpdate = st;
 	if( !st )
 	  ptPrepare.reset();
@@ -150,7 +151,7 @@ void UNetReceiver::setLockUpdate( bool st )
 // -----------------------------------------------------------------------------
 void UNetReceiver::resetTimeout()
 {
-	uniset_mutex_lock l(tmMutex,200);
+	uniset_rwmutex_wrlock l(tmMutex);
 	ptRecvTimeout.reset();
 	trTimeout.change(false);
 }
@@ -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

@@ -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

@@ -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

@@ -89,7 +89,7 @@ class UNetSender
 		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

@@ -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

@@ -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

@@ -105,7 +105,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/lib/IOBase.cc

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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/UniSetObject.h

@@ -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

@@ -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

@@ -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

@@ -193,7 +193,7 @@ class ModbusClient
 		
 		bool crcNoCheckit;
 
-		UniSetTypes::uniset_mutex sendMutex;
+		UniSetTypes::uniset_rwmutex sendMutex;
 		DebugStream dlog;
 
 		void printProcessingTime();

include/modbus/ModbusRTUSlave.h

@@ -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 );

src/Communications/Modbus/ModbusClient.cc

@@ -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

@@ -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

@@ -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

@@ -2387,7 +2387,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();
@@ -2410,16 +2410,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);
@@ -2434,13 +2425,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();)
 	{
@@ -2459,7 +2449,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

@@ -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

@@ -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/Processes/IOController.cc

@@ -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)
@@ -508,7 +508,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 )
@@ -574,7 +574,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;
@@ -624,7 +624,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);
@@ -702,7 +702,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);
@@ -775,6 +775,7 @@ void IOController::sUnRegistration( const IOController_i::SensorInfo& si )
 
 void IOController::logging( UniSetTypes::SensorMessage& sm )
 {
+	uniset_rwmutex_wrlock l(loggingMutex);
 	try
 	{
 //		struct timezone tz;
@@ -786,18 +787,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;
 		}
 	}
 }
@@ -813,7 +812,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;
@@ -834,7 +833,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;
@@ -864,7 +863,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++;
 		}
@@ -885,7 +884,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;
@@ -942,7 +941,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;
 	}
 
@@ -962,7 +961,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;
 	}
 
@@ -1341,7 +1340,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;
@@ -1361,7 +1360,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;
 			}
@@ -1422,7 +1421,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;
@@ -1433,7 +1432,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;
@@ -1460,7 +1459,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;
@@ -1471,7 +1470,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

@@ -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

@@ -28,7 +28,6 @@
 #include <pthread.h>
 #include <time.h>
 
-#include "PosixThread.h"
 #include "PassiveTimer.h"
 
 // ------------------------------------------------------------------------------------------

src/Various/Mutex.cc

@@ -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

+#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

@@ -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();