Skip to content

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

fixed after backport to p9

parent a2213d77
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 1 addition and 1107 deletions
configure.ac
View file @ d03993a8
......@@ -3,17 +3,8 @@
# See doc: http://www.gnu.org/software/hello/manual/autoconf/Generic-Programs.html
# AC_PREREQ(2.59)
<<<<<<< HEAD
<<<<<<< HEAD
AC_INIT([uniset2], [2.8.1], pv@etersoft.ru)
AM_INIT_AUTOMAKE(AC_PACKAGE_NAME,AC_PACKAGE_VERSION)
=======
AC_INIT([uniset2], [2.9.1], pv@etersoft.ru)
=======
AC_INIT([uniset2], [2.9.2], pv@etersoft.ru)
>>>>>>> 2.9.2-alt1
AM_INIT_AUTOMAKE
>>>>>>> 2.9.1-alt1
LIBVER=11:2:9
AC_SUBST(LIBVER)
......
extensions/UNetUDP/UDPPacket.cc
View file @ d03993a8
......@@ -23,7 +23,6 @@
// myvar = LE_TO_H(myvar)
// -------------------------------------------------------------------------
#if __BYTE_ORDER == __LITTLE_ENDIAN
static bool HostIsBigEndian = false;
#define LE_TO_H(x) {}
#elif INTPTR_MAX == INT64_MAX
#define LE_TO_H(x) x = le64toh(x)
......@@ -34,8 +33,7 @@ static bool HostIsBigEndian = false;
#endif
#if __BYTE_ORDER == __BIG_ENDIAN
static bool HostIsBigEndian = true;
header.#define BE_TO_H(x) {}
#define BE_TO_H(x) {}
#elif INTPTR_MAX == INT64_MAX
#define BE_TO_H(x) x = be64toh(x)
#elif INTPTR_MAX == INT32_MAX
......@@ -114,191 +112,6 @@ namespace uniset
}
#endif
<<<<<<< HEAD
// crc = crc & 0xffff;
}
return crc;
}
// -------------------------------------------------------------------------
uint16_t UniSetUDP::makeCRC( unsigned char* buf, size_t len ) noexcept
{
uint16_t crc = 0xffff;
crc = get_crc_16(crc, (unsigned char*)(buf), len);
return crc;
}
// -----------------------------------------------------------------------------
std::ostream& UniSetUDP::operator<<( std::ostream& os, UniSetUDP::UDPHeader& p )
{
return os << "nodeID=" << p.nodeID
<< " procID=" << p.procID
<< " dcount=" << p.dcount
<< " acount=" << p.acount
<< " pnum=" << p.num;
}
// -----------------------------------------------------------------------------
std::ostream& UniSetUDP::operator<<( std::ostream& os, UniSetUDP::UDPHeader* p )
{
return os << (*p);
}
// -----------------------------------------------------------------------------
std::ostream& UniSetUDP::operator<<( std::ostream& os, UniSetUDP::UDPAData& p )
{
return os << "id=" << p.id << " val=" << p.val;
}
// -----------------------------------------------------------------------------
std::ostream& UniSetUDP::operator<<( std::ostream& os, UniSetUDP::UDPMessage& p )
{
os << (UDPHeader*)(&p) << endl;
os << "DIGITAL:" << endl;
for( size_t i = 0; i < p.header.dcount; i++ )
os << "[" << i << "]={" << p.dID(i) << "," << p.dValue(i) << "}" << endl;
os << "ANALOG:" << endl;
for( size_t i = 0; i < p.header.acount; i++ )
os << "[" << i << "]={" << p.a_dat[i].id << "," << p.a_dat[i].val << "}" << endl;
return os;
}
// -----------------------------------------------------------------------------
size_t UDPMessage::addAData( const UniSetUDP::UDPAData& dat ) noexcept
{
if( header.acount >= MaxACount )
return MaxACount;
a_dat[header.acount] = dat;
header.acount++;
return header.acount - 1;
}
// -----------------------------------------------------------------------------
size_t UDPMessage::addAData( long id, long val) noexcept
{
UDPAData d(id, val);
return addAData(d);
}
// -----------------------------------------------------------------------------
bool UDPMessage::setAData( size_t index, long val ) noexcept
{
if( index < MaxACount )
{
a_dat[index].val = val;
return true;
}
return false;
}
// -----------------------------------------------------------------------------
size_t UDPMessage::addDData( long id, bool val ) noexcept
{
if( header.dcount >= MaxDCount )
return MaxDCount;
// сохраняем ID
d_id[header.dcount] = id;
bool res = setDData( header.dcount, val );
if( res )
{
header.dcount++;
return header.dcount - 1;
}
return MaxDCount;
}
// -----------------------------------------------------------------------------
bool UDPMessage::setDData( size_t index, bool val ) noexcept
{
if( index >= MaxDCount )
return false;
size_t nbyte = index / 8 * sizeof(uint8_t);
size_t nbit = index % 8 * sizeof(uint8_t);
// выставляем бит
unsigned char d = d_dat[nbyte];
if( val )
d |= (1 << nbit);
else
d &= ~(1 << nbit);
d_dat[nbyte] = d;
return true;
}
// -----------------------------------------------------------------------------
long UDPMessage::dID( size_t index ) const noexcept
{
if( index >= MaxDCount )
return uniset::DefaultObjectId;
return d_id[index];
}
// -----------------------------------------------------------------------------
bool UDPMessage::dValue( size_t index ) const noexcept
{
if( index >= MaxDCount )
return uniset::DefaultObjectId;
size_t nbyte = index / 8 * sizeof(uint8_t);
size_t nbit = index % 8 * sizeof(uint8_t);
return ( d_dat[nbyte] & (1 << nbit) );
}
// -----------------------------------------------------------------------------
long UDPMessage::getDataID() const noexcept
{
// в качестве идентификатора берётся ID первого датчика в данных
// приоритет имеет аналоговые датчики
if( header.acount > 0 )
return a_dat[0].id;
if( header.dcount > 0 )
return d_id[0];
// если нет данных(?) просто возвращаем номер пакета
return header.num;
}
// -----------------------------------------------------------------------------
bool UDPMessage::isOk() noexcept
{
return ( header.magic == UniSetUDP::UNETUDP_MAGICNUM );
}
// -----------------------------------------------------------------------------
void UDPMessage::ntoh() noexcept
{
// byte order from packet
uint8_t be_order = header._be_order;
if( be_order && !HostIsBigEndian )
{
BE_TO_H(header.magic);
BE_TO_H(header.num);
BE_TO_H(header.procID);
BE_TO_H(header.nodeID);
BE_TO_H(header.dcount);
BE_TO_H(header.acount);
}
else if( !be_order && HostIsBigEndian )
{
LE_TO_H(header.magic);
LE_TO_H(header.num);
LE_TO_H(header.procID);
LE_TO_H(header.nodeID);
LE_TO_H(header.dcount);
LE_TO_H(header.acount);
}
// set host byte order
#if __BYTE_ORDER == __LITTLE_ENDIAN
header._be_order = 0;
#elif __BYTE_ORDER == __BIG_ENDIAN
header._be_order = 1;
=======
// crc = crc & 0xffff;
}
......@@ -531,56 +344,10 @@ namespace uniset
m._be_order = 0;
#elif __BYTE_ORDER == __BIG_ENDIAN
m. be_order = 1;
>>>>>>> 2.9.1-alt1
#else
#error UNET(getMessage): Unknown byte order!
#endif
<<<<<<< HEAD
// CONVERT DATA TO HOST BYTE ORDER
// -------------------------------
if( (be_order && !HostIsBigEndian) || (!be_order && HostIsBigEndian) )
{
for( size_t n = 0; n < header.acount; n++ )
{
if( be_order )
{
BE_TO_H(a_dat[n].id);
BE_TO_H(a_dat[n].val);
}
else
{
LE_TO_H(a_dat[n].id);
LE_TO_H(a_dat[n].val);
}
}
for( size_t n = 0; n < header.dcount; n++ )
{
if( be_order )
{
BE_TO_H(d_id[n]);
}
else
{
LE_TO_H(d_id[n]);
}
}
}
}
// -----------------------------------------------------------------------------
uint16_t UDPMessage::getDataCRC() const noexcept
{
uint16_t crc[3];
crc[0] = makeCRC( (unsigned char*)(a_dat), sizeof(a_dat) );
crc[1] = makeCRC( (unsigned char*)(d_id), sizeof(d_id) );
crc[2] = makeCRC( (unsigned char*)(d_dat), sizeof(d_dat) );
return makeCRC( (unsigned char*)(&crc), sizeof(crc) );
}
UDPHeader::UDPHeader() noexcept
: magic(UNETUDP_MAGICNUM)
=======
// проверяем наш ли пакет..
if( m.magic != UniSetUDP::UNETUDP_MAGICNUM )
{
......@@ -658,7 +425,6 @@ namespace uniset
UDPHeader::UDPHeader() noexcept
: magic(UNETUDP_MAGICNUM)
>>>>>>> 2.9.1-alt1
#if __BYTE_ORDER == __LITTLE_ENDIAN
, _be_order(0)
#elif __BYTE_ORDER == __BIG_ENDIAN
......
extensions/UNetUDP/UDPPacket.h
View file @ d03993a8
......@@ -24,15 +24,6 @@
// --------------------------------------------------------------------------
namespace uniset
{
<<<<<<< HEAD
// -----------------------------------------------------------------------------
namespace UniSetUDP
{
/*! С учётом того, что ID могут идти не подряд. Сделан следующий формат:
Для аналоговых величин передаётся массив пар "id-value"(UDPAData).
Для булевых величин - отдельно массив ID и отдельно битовый массив со значениями,
(по количеству битов такого же размера).
=======
// -----------------------------------------------------------------------------
namespace UniSetUDP
{
......@@ -44,7 +35,6 @@ namespace uniset
\todo Подумать на тему сделать два отдельных вида пакетов для булевых значений и для аналоговых,
чтобы уйти от преобразования UDPMessage --> UDPPacket --> UDPMessage.
>>>>>>> 2.9.1-alt1
\warning ТЕКУЩАЯ ВЕРСИЯ ПРОТОКОЛА НЕ БУДЕТ РАБОТАТЬ МЕЖДУ 32-битными и 64-битными системами (из-за отличия в типе long).
т.к. это не сильно актуально, пока не переделываю.
......@@ -59,21 +49,6 @@ namespace uniset
Т.е. если все узлы будут иметь одинаковый порядок байт, фактического перекодирования не будет.
*/
<<<<<<< HEAD
const uint32_t UNETUDP_MAGICNUM = 0x1343EFD; // идентификатор протокола
struct UDPHeader
{
UDPHeader() noexcept;
uint32_t magic;
uint8_t _be_order; // 1 - BE byte order, 0 - LE byte order
size_t num;
long nodeID;
long procID;
size_t dcount; /*!< количество булевых величин */
size_t acount; /*!< количество аналоговых величин */
} __attribute__((packed));
=======
const uint32_t UNETUDP_MAGICNUM = 0x133EF54; // идентификатор протокола
struct UDPHeader
......@@ -89,7 +64,6 @@ namespace uniset
size_t acount; /*!< количество аналоговых величин */
} __attribute__((packed));
>>>>>>> 2.9.1-alt1
std::ostream& operator<<( std::ostream& os, UDPHeader& p );
std::ostream& operator<<( std::ostream& os, UDPHeader* p );
......@@ -108,21 +82,6 @@ namespace uniset
std::ostream& operator<<( std::ostream& os, UDPAData& p );
<<<<<<< HEAD
// Теоретический размер данных в UDP пакете (исключая заголовки) 65507
// Фактически желательно не вылезать за размер MTU (обычно 1500) - заголовки = 1432 байта
// т.е. надо чтобы sizeof(UDPPacket) < 1432
// При текущих настройках sizeof(UDPPacket) = 56421 (!)
static const size_t MaxACount = 2000;
static const size_t MaxDCount = 3000;
static const size_t MaxDDataCount = 1 + MaxDCount / 8 * sizeof(uint8_t);
struct UDPMessage
{
// net to host
void ntoh() noexcept;
bool isOk() noexcept;
=======
// Теоретический размер данных в UDP пакете (исключая заголовки) 65507
// Фактически желательно не вылезать за размер MTU (обычно 1500) - заголовки = 1432 байта
// т.е. надо чтобы sizeof(UDPPacket) < 1432
......@@ -159,7 +118,6 @@ namespace uniset
size_t transport_msg( UDPPacket& p ) const noexcept;
static size_t getMessage( UDPMessage& m, UDPPacket& p ) noexcept;
>>>>>>> 2.9.1-alt1
// \warning в случае переполнения возвращается MaxDCount
size_t addDData( long id, bool val ) noexcept;
......@@ -183,39 +141,6 @@ namespace uniset
long getDataID( ) const noexcept; /*!< получение "уникального" идентификатора данных этого пакета */
<<<<<<< HEAD
inline bool isAFull() const noexcept
{
return (header.acount >= MaxACount);
}
inline bool isDFull() const noexcept
{
return (header.dcount >= MaxDCount);
}
inline bool isFull() const noexcept
{
return !((header.dcount < MaxDCount) && (header.acount < MaxACount));
}
inline size_t dsize() const noexcept
{
return header.dcount;
}
inline size_t asize() const noexcept
{
return header.acount;
}
uint16_t getDataCRC() const noexcept;
UDPHeader header;
UDPAData a_dat[MaxACount]; /*!< аналоговые величины */
long d_id[MaxDCount]; /*!< список дискретных ID */
uint8_t d_dat[MaxDDataCount]; /*!< битовые значения */
} __attribute__((packed));
=======
inline bool isAFull() const noexcept
{
return (acount >= MaxACount);
......@@ -255,7 +180,6 @@ namespace uniset
long d_id[MaxDCount]; /*!< список дискретных ID */
uint8_t d_dat[MaxDDataCount]; /*!< битовые значения */
};
>>>>>>> 2.9.1-alt1
std::ostream& operator<<( std::ostream& os, UDPMessage& p );
......
extensions/UNetUDP/UNetSender.h
View file @ d03993a8
......@@ -33,154 +33,6 @@
// --------------------------------------------------------------------------
namespace uniset
{
<<<<<<< HEAD
// -----------------------------------------------------------------------------
/*
* Распределение датчиков по пакетам
* =========================================================================
* Все пересылаемые данные разбиваются на группы по частоте посылки("sendfactor").
* Частота посылки кратна sendpause, задаётся для каждого датчика, при помощи свойства prefix_sendfactor.
* Внутри каждой группы пакеты набираются по мере "заполнения".
*
* Добавление датчика в пакет и создание нового пакета при переполнении происходит в функции initItem().
* Причем так как дискретные и аналоговые датчики обрабатываются отдельно (но пересылаются в одном пакете),
* то датчики, которые первые переполнятся приводят к тому, что создаётся новый пакет и они добавляются в него,
* в свою очередь остальные продолжают "добивать" предыдущий пакет.
* В initItem() каждому UItem в dlist кроме pack_ind присваивается еще и номер пакета pack_num, который гарантировано соответствует
* существующему пакету, поэтому в дальнейшем при использовании pack_num в качестве ключа в mypacks мы не проверяем пакет на существование.
*
* ОПТИМИЗАЦИЯ N1: Для оптимизации обработки посылаемых пакетов (на стороне UNetSender) сделана следующая логика:
* Номер очередного посылаемого пакета меняется (увеличивается) только, если изменились данные с момента
последней посылки. Для этого по данным каждый раз производится расчёт UNetUDP::makeCRC() и сравнивается с последним.
На стороне UNetReceiver пакеты с повторными номерами (т.е. уже обработанные) - откидываются.
*
*
* Создание соединения
* ======================================
* Попытка создать соединение производиться сразу в конструкторе, если это не получается,
* то в потоке "посылки", с заданным периодом (checkConnectionTime) идёт попытка создать соединение..
* и так бесконечно, пока не получиться. Это важно для систем, где в момент загрузки программы
* (в момент создания объекта UNetSender) ещё может быть не поднята сеть или какой-то сбой с сетью и требуется
* ожидание (без вылета программы) пока "внешняя система мониторинга" не поднимет сеть).
* Если такая логика не требуется, то можно задать в конструкторе флаг nocheckconnection=true,
* тогда при создании объекта UNetSender, в конструкторе будет
* выкинуто исключение при неудачной попытке создания соединения.
* \warning setCheckConnectionPause(msec) должно быть кратно sendpause!
*/
class UNetSender
{
public:
UNetSender( const std::string& host, const int port, const std::shared_ptr<SMInterface>& smi
, bool nocheckConnection = false
, const std::string& s_field = ""
, const std::string& s_fvalue = ""
, const std::string& prop_prefix = "unet"
, const std::string& prefix = "unet"
, size_t maxDCount = UniSetUDP::MaxDCount
, size_t maxACount = UniSetUDP::MaxACount );
virtual ~UNetSender();
typedef size_t sendfactor_t;
static const long not_specified_value = { std::numeric_limits<long>::max() };
struct UItem
{
UItem():
iotype(UniversalIO::UnknownIOType),
id(uniset::DefaultObjectId),
pack_num(0),
pack_ind(0),
pack_sendfactor(0) {}
UniversalIO::IOType iotype;
uniset::ObjectId id;
IOController::IOStateList::iterator ioit;
size_t pack_num;
size_t pack_ind;
sendfactor_t pack_sendfactor = { 0 };
long undefined_value = { not_specified_value };
friend std::ostream& operator<<( std::ostream& os, UItem& p );
};
typedef std::unordered_map<uniset::ObjectId, UItem> UItemMap;
size_t getDataPackCount() const;
void start();
void stop();
void send() noexcept;
struct PackMessage
{
PackMessage( uniset::UniSetUDP::UDPMessage&& m ) noexcept: msg(std::move(m)) {}
PackMessage( const uniset::UniSetUDP::UDPMessage& m ) = delete;
PackMessage() noexcept {}
uniset::UniSetUDP::UDPMessage msg;
uniset::uniset_rwmutex mut;
};
void real_send( PackMessage& mypack ) noexcept;
/*! (принудительно) обновить все данные (из SM) */
void updateFromSM();
/*! Обновить значение по ID датчика */
void updateSensor( uniset::ObjectId id, long value );
/*! Обновить значение по итератору */
void updateItem( UItem& it, long value );
inline void setSendPause( int msec )
{
sendpause = msec;
}
inline void setPackSendPause( int msec )
{
packsendpause = msec;
}
inline void setPackSendPauseFactor( int factor )
{
packsendpauseFactor = factor;
}
void setCheckConnectionPause( int msec );
/*! заказать датчики */
void askSensors( UniversalIO::UIOCommand cmd );
/*! инициализация итераторов */
void initIterators();
inline std::shared_ptr<DebugStream> getLog()
{
return unetlog;
}
virtual const std::string getShortInfo() const;
inline std::string getAddress() const
{
return addr;
}
inline int getPort() const
{
return port;
}
inline size_t getADataSize() const
{
return maxAData;
}
inline size_t getDDataSize() const
{
return maxDData;
}
=======
// -----------------------------------------------------------------------------
/*
* Распределение датчиков по пакетам
......@@ -327,7 +179,6 @@ namespace uniset
{
return maxDData;
}
>>>>>>> 2.9.1-alt1
protected:
......@@ -354,36 +205,6 @@ namespace uniset
std::string s_host = { "" };
Poco::Net::SocketAddress saddr;
<<<<<<< HEAD
std::string myname = { "" };
timeout_t sendpause = { 150 };
timeout_t packsendpause = { 5 };
int packsendpauseFactor = { 1 };
timeout_t writeTimeout = { 1000 }; // msec
std::atomic_bool activated = { false };
PassiveTimer ptCheckConnection;
typedef std::unordered_map<sendfactor_t, std::vector<PackMessage>> Packs;
// mypacks заполняется в начале и дальше с ним происходит только чтение
// поэтому mutex-ом его не защищаем
Packs mypacks;
std::unordered_map<sendfactor_t, size_t> packs_anum;
std::unordered_map<sendfactor_t, size_t> packs_dnum;
UItemMap items;
size_t packetnum = { 1 }; /*!< номер очередного посылаемого пакета */
uint16_t lastcrc = { 0 };
size_t maxAData = { UniSetUDP::MaxACount };
size_t maxDData = { UniSetUDP::MaxDCount };
std::unique_ptr< ThreadCreator<UNetSender> > s_thr; // send thread
size_t ncycle = { 0 }; /*!< номер цикла посылки */
};
// --------------------------------------------------------------------------
=======
std::string myname = { "" };
timeout_t sendpause = { 150 };
timeout_t packsendpause = { 5 };
......@@ -413,7 +234,6 @@ namespace uniset
};
// --------------------------------------------------------------------------
>>>>>>> 2.9.1-alt1
} // end of namespace uniset
// -----------------------------------------------------------------------------
#endif // UNetSender_H_
......
extensions/UNetUDP/tests/Makefile.am
View file @ d03993a8
if HAVE_TESTS
noinst_PROGRAMS = tests-with-sm urecv-perf-test
#noinst_PROGRAMS = urecv-perf-test
tests_with_sm_SOURCES = tests_with_sm.cc test_unetudp.cc
tests_with_sm_LDADD = $(top_builddir)/lib/libUniSet2.la $(top_builddir)/extensions/lib/libUniSet2Extensions.la \
......
extensions/UNetUDP/tests/urecv_perf_test.cc
View file @ d03993a8
......@@ -32,104 +32,6 @@ shared_ptr<SMInterface> smiInstance()
// --------------------------------------------------------------------------
static void run_senders( size_t max, const std::string& s_host, size_t count = 50, timeout_t usecpause = 50 )
{
<<<<<<< HEAD
std::vector< std::shared_ptr<UDPSocketU> > vsend;
vsend.reserve(max);
cout << "Run " << max << " senders (" << s_host << ")" << endl;
// make sendesrs..
for( size_t i = 0; i < max; i++ )
{
try
{
cout << "create sender: " << s_host << ":" << begPort + i << endl;
auto s = make_shared<UDPSocketU>(s_host, begPort + i);
s->setBroadcast(true);
vsend.emplace_back(s);
}
catch( Poco::Net::NetException& e )
{
cerr << "(run_senders): " << e.displayText() << " (" << s_host << ")" << endl;
throw;
}
catch( std::exception& ex)
{
cerr << "(run_senders): " << ex.what() << endl;
throw;
}
}
UniSetUDP::UDPMessage mypack;
mypack.header.nodeID = 100;
mypack.header.procID = 100;
for( size_t i = 0; i < count; i++ )
{
UniSetUDP::UDPAData d(i, i);
mypack.addAData(d);
}
for( size_t i = 0; i < count; i++ )
mypack.addDData(i, i);
for( size_t i = 0; i < max; i++ )
{
try
{
if( vsend[i] )
vsend[i]->connect( Poco::Net::SocketAddress(s_host, begPort + i) );
}
catch( Poco::Net::NetException& e )
{
cerr << "(run_senders): " << e.message() << " (" << s_host << ")" << endl;
throw;
}
catch( std::exception& ex)
{
cerr << "(run_senders): " << ex.what() << endl;
throw;
}
}
size_t packetnum = 0;
size_t nc = 1;
while( nc ) // -V654
{
mypack.header.num = packetnum++;
// при переходе черех максимум (UniSetUDP::MaxPacketNum)
// пакет опять должен иметь номер "1"
if( packetnum == 0 )
packetnum = 1;
for( auto&& udp : vsend )
{
try
{
if( udp->poll(100000, Poco::Net::Socket::SELECT_WRITE) )
{
size_t ret = udp->sendBytes(&mypack, sizeof(mypack));
if( ret < sizeof(mypack) )
cerr << "(send): FAILED ret=" << ret << " < sizeof=" << sizeof(mypack) << endl;
}
}
catch( Poco::Net::NetException& e )
{
cerr << "(send): " << e.message() << " (" << s_host << ")" << endl;
}
catch( ... )
{
cerr << "(send): catch ..." << endl;
}
}
std::this_thread::sleep_for(std::chrono::microseconds(usecpause));
}
=======
std::vector< std::shared_ptr<UDPSocketU> > vsend;
vsend.reserve(max);
......@@ -227,47 +129,10 @@ static void run_senders( size_t max, const std::string& s_host, size_t count = 5
std::this_thread::sleep_for(std::chrono::microseconds(usecpause));
}
>>>>>>> 2.9.1-alt1
}
// --------------------------------------------------------------------------
static void run_test( size_t max, const std::string& host )
{
<<<<<<< HEAD
std::vector< std::shared_ptr<UNetReceiver> > vrecv;
vrecv.reserve(max);
// make receivers..
for( size_t i = 0; i < max; i++ )
{
cout << "create receiver: " << host << ":" << begPort + i << endl;
auto r = make_shared<UNetReceiver>(host, begPort + i, smiInstance());
r->setLockUpdate(true);
vrecv.emplace_back(r);
}
size_t count = 0;
// Run receivers..
for( auto&& r : vrecv )
{
if( r )
{
count++;
r->start();
}
}
cerr << "RUN " << count << " receivers..." << endl;
// wait..
pause();
for( auto&& r : vrecv )
{
if(r)
r->stop();
}
=======
std::vector< std::shared_ptr<UNetReceiver> > vrecv;
vrecv.reserve(max);
......@@ -301,44 +166,10 @@ static void run_test( size_t max, const std::string& host )
if(r)
r->stop();
}
>>>>>>> 2.9.1-alt1
}
// --------------------------------------------------------------------------
int main(int argc, char* argv[] )
{
<<<<<<< HEAD
std::string host = "127.255.255.255";
try
{
auto conf = uniset_init(argc, argv);
if( argc > 1 && !strcmp(argv[1], "s") )
run_senders(1, host);
else
run_test(1, host);
return 0;
}
catch( const SystemError& err )
{
cerr << "(urecv-perf-test): " << err << endl;
}
catch( const uniset::Exception& ex )
{
cerr << "(urecv-perf-test): " << ex << endl;
}
catch( const std::exception& e )
{
cerr << "(tests_with_sm): " << e.what() << endl;
}
catch(...)
{
cerr << "(urecv-perf-test): catch(...)" << endl;
}
return 1;
=======
std::string host = "127.255.255.255";
try
......@@ -370,5 +201,4 @@ int main(int argc, char* argv[] )
}
return 1;
>>>>>>> 2.9.1-alt1
}
uniset2.files
View file @ d03993a8
<<<<<<< HEAD
./cov-int/emit/pvbook.localdomain/config/130ac2dc34760443befdd3f2a25f8d40/g++cc-config-0/coverity-compiler-compat.h
./cov-int/emit/pvbook.localdomain/config/130ac2dc34760443befdd3f2a25f8d40/gcc-config-0/coverity-compiler-compat.h
./cov-int/emit/pvbook.localdomain/config/130ac2dc34760443befdd3f2a25f8d40/g++cc-config-0/coverity-macro-compat.h
./cov-int/emit/pvbook.localdomain/config/130ac2dc34760443befdd3f2a25f8d40/gcc-config-0/coverity-macro-compat.h
./cov-int/emit/pvbook.localdomain/config/130ac2dc34760443befdd3f2a25f8d40/g++cc-config-1/coverity-compiler-compat.h
./cov-int/emit/pvbook.localdomain/config/130ac2dc34760443befdd3f2a25f8d40/g++cc-config-1/coverity-macro-compat.h
./cov-int/emit/pvbook.localdomain/config/130ac2dc34760443befdd3f2a25f8d40/g++-config-0/coverity-compiler-compat.h
./cov-int/emit/pvbook.localdomain/config/130ac2dc34760443befdd3f2a25f8d40/g++-config-0/coverity-macro-compat.h
./cov-int/emit/pvbook.localdomain/config/130ac2dc34760443befdd3f2a25f8d40/g++-config-1/coverity-compiler-compat.h
./cov-int/emit/pvbook.localdomain/config/130ac2dc34760443befdd3f2a25f8d40/g++-config-1/coverity-macro-compat.h
./cov-int/emit/pvbook.localdomain/config/30c6834cc1e9802742e33de4efa3917c/g++cc-config-0/coverity-compiler-compat.h
./cov-int/emit/pvbook.localdomain/config/30c6834cc1e9802742e33de4efa3917c/g++cc-config-0/coverity-macro-compat.h
./cov-int/emit/pvbook.localdomain/config/30c6834cc1e9802742e33de4efa3917c/g++-config-0/coverity-compiler-compat.h
./cov-int/emit/pvbook.localdomain/config/30c6834cc1e9802742e33de4efa3917c/g++-config-0/coverity-macro-compat.h
./cov-int/emit/pvbook.localdomain/config/4d02eb73c555e8f07e4124fe33c80de2/g++cc-config-0/coverity-compiler-compat.h
./cov-int/emit/pvbook.localdomain/config/4d02eb73c555e8f07e4124fe33c80de2/g++cc-config-0/coverity-macro-compat.h
./cov-int/emit/pvbook.localdomain/config/4d02eb73c555e8f07e4124fe33c80de2/g++-config-0/coverity-compiler-compat.h
./cov-int/emit/pvbook.localdomain/config/4d02eb73c555e8f07e4124fe33c80de2/g++-config-0/coverity-macro-compat.h
./cov-int/emit/pvbook.localdomain/config/4db70a7a9c958929fa315f4c9243d800/g++cc-config-0/coverity-compiler-compat.h
./cov-int/emit/pvbook.localdomain/config/4db70a7a9c958929fa315f4c9243d800/g++cc-config-0/coverity-macro-compat.h
./cov-int/emit/pvbook.localdomain/config/4db70a7a9c958929fa315f4c9243d800/g++-config-0/coverity-compiler-compat.h
./cov-int/emit/pvbook.localdomain/config/4db70a7a9c958929fa315f4c9243d800/g++-config-0/coverity-macro-compat.h
=======
>>>>>>> 2.9.1-alt1
./docs/Makefile.am
./extensions/Backend-OpenTSDB/BackendOpenTSDB.cc
./extensions/Backend-OpenTSDB/BackendOpenTSDB.h
......@@ -49,8 +24,6 @@
./extensions/DBServer-SQLite/SQLiteInterface.cc
./extensions/DBServer-SQLite/SQLiteInterface.h
./extensions/DBServer-SQLite/test.cc
<<<<<<< HEAD
=======
./extensions/HttpResolver/HttpResolver.cc
./extensions/HttpResolver/HttpResolver.h
./extensions/HttpResolver/HttpResolverSugar.h
......@@ -61,7 +34,6 @@
./extensions/HttpResolver/tests/TestObject.cc
./extensions/HttpResolver/tests/TestObject.h
./extensions/HttpResolver/tests/test_uresolver.cc
>>>>>>> 2.9.1-alt1
./extensions/include/Calibration.h
./extensions/include/ComediInterface.h
./extensions/include/DigitalFilter.h
......@@ -148,11 +120,8 @@
./extensions/Makefile.am
./extensions/ModbusMaster/main.cc
./extensions/ModbusMaster/Makefile.am
<<<<<<< HEAD
=======
./extensions/ModbusMaster/MBConfig.cc
./extensions/ModbusMaster/MBConfig.h
>>>>>>> 2.9.1-alt1
./extensions/ModbusMaster/MBExchange.cc
./extensions/ModbusMaster/MBExchange.h
./extensions/ModbusMaster/mb-perf-test.cc
......@@ -226,8 +195,6 @@
./extensions/SMViewer/Makefile.am
./extensions/SMViewer/SMViewer.cc
./extensions/SMViewer/SMViewer.h
<<<<<<< HEAD
=======
./extensions/tests1/Makefile.am
./extensions/tests1/MBSlaveTest/Makefile.am
./extensions/tests1/MBSlaveTest/mbslave-test.cc
......@@ -265,7 +232,6 @@
./extensions/tests1/tests_with_sm.h
./extensions/tests1/test_ui.cc
./extensions/tests1/test_vtypes.cc
>>>>>>> 2.9.1-alt1
./extensions/tests/Makefile.am
./extensions/tests/MBSlaveTest/Makefile.am
./extensions/tests/MBSlaveTest/mbslave-test.cc
......@@ -313,10 +279,6 @@
./extensions/UNetUDP/tests/u.cc
./extensions/UNetUDP/tests/urecv_perf_test.cc
./extensions/UNetUDP/UDPPacket.cc
<<<<<<< HEAD
./extensions/UNetUDP/UDPPacketE.h
=======
>>>>>>> 2.9.1-alt1
./extensions/UNetUDP/UDPPacket.h
./extensions/UNetUDP/unetexchange.cc
./extensions/UNetUDP/UNetExchange.cc
......@@ -406,10 +368,7 @@
./include/UA.h
./include/UDPCore.h
./include/UHelpers.h
<<<<<<< HEAD
=======
./include/UHttpClient.h
>>>>>>> 2.9.1-alt1
./include/UHttpRequestHandler.h
./include/UHttpServer.h
./include/UInterface.h
......@@ -432,10 +391,7 @@
./src/Communications/ComPort485F.cc
./src/Communications/ComPort.cc
./src/Communications/Http/Makefile.am
<<<<<<< HEAD
=======
./src/Communications/Http/UHttpClient.cc
>>>>>>> 2.9.1-alt1
./src/Communications/Http/UHttpRequestHandler.cc
./src/Communications/Http/UHttpServer.cc
./src/Communications/Makefile.am
......@@ -594,10 +550,6 @@
./tests/umutex.cc
./tests/UniXmlTest/Makefile.am
./tests/UniXmlTest/XmlTest.cc
<<<<<<< HEAD
./tt.cc
=======
>>>>>>> 2.9.1-alt1
./uniset-config.h
./Utilities/Admin/admin.cc
./Utilities/Admin/c.cc
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment