Introducing performance_test benchmarks tool for eCAL. #660
Replies: 7 comments 17 replies
-
|
Thanks for sharing, looks like a cool project! At first I thought it would use rmw_ecal, but I checked the code and you are really doing raw-ecal there (which is good, as the performance may differ for obvious reasons). Do you have results of any kind that you can share? |
Beta Was this translation helpful? Give feedback.
-
test result by handos performance tunningcpu power-savingsudo nano /etc/default/grub
GRUB_CMDLINE_LINUX="nosmt processor.max_cstate=0 intel_idle.max_cstate=0"
sudo update-grub
sudo reboot -h nowcpu performance-modesudo apt-get install cpufrequtils
# to get the highest freq
sudo cpufreq-set -g performancenetwork-stack64MB sudo cpufreq-set -g performance
sudo sysctl -w net.ipv4.udp_mem="10240087380016777216"
sudo sysctl -w net.core.netdev_max_backlog="30000"
sudo sysctl -w net.core.rmem_max="67108864"
sudo sysctl -w net.core.wmem_max="67108864"
sudo sysctl -w net.core.rmem_default="67108864"
sudo sysctl -w net.core.wmem_default="67108864"swapsudo swapoff -a
sudo nano /etc/fstab
# comment the swap configresultthe unit is ms.
@FlorianReimold must be something wrong with my code, I will keep checking the ecal test program. test envDELL-3630 PC
|
Beta Was this translation helpful? Give feedback.
-
|
Thanks for sharing the results! We will now try to replicate those on our own hardware (so be prepared that we approach you when we have issues with that 😁) We have already taken a short look (like 15 minutes) at the code and found some things that we know (or assume) are inefficient:
Nevertheless, we are going to check your code and maybe provide further infos! 🙌 |
Beta Was this translation helpful? Give feedback.
-
the new version of the performance_test is just as simple as the old one, only to take care of the git repo address, I changed them from
I know the message-type agnostic of eCAL, but I found it hard to use eCAL::CPublisher and eCAL::string::CPublisher, I tried to use the
So finally, I gave up using raw publisher, and use the protobuf::CPublisher, then I need to define the proto of It'a true that there's lack of bounded array size definition in proto, So I found the
The
Do you mean that the ptotobuf does not support zero copy transport in any way?
I will have a try to use flatbuffer::CPublisher if possible
As already said, I will try that way again, could you give an example of publish an
What I want is to find an easy way to do shm and zero copy transport for ros2 galactic, the zero copy of rmw_fastrtps cannot be stable in galactic, the shm is not provided in rmw_cyclonedds galactic, it looks like the eCAL will be the best answer. Thanks. |
Beta Was this translation helpful? Give feedback.
-
Oh, that's interesting, you cannot access GitHub from China? That's a shame, I didn't know that. So you always have to use VPNs to get through the great Firewall?
You can use the CPublisher and CSubscriber in just the same way with a callback, but the callback signature is a little bit different. When receiving data it will return a pointer to raw memory and a size. In Zero-copy mode that pointer will point to the SHM file.
The repeated field is great when repeating complex types. Like protobuf messages. But when using it for a binary array you massively lose performance due to the serialization overhead, as protobuf will then serialize each element individually instead of just copying the whole blob.
That's one of the improvements. I know that it may seem like a step back, but Google had their reasons and dropped default values as well as the optional / required field in favor of better performance and easier API.
Yes, that's correct. Protobuf will always have to de-serialize the message before being able to access the fields. That causes a copy (obviously). It's similar like a Zip File - to access the content you will have to unzip the files to some (temporary) location. For actual zero-copy you have to operate on the binary data without de-serialization, so you have to use a message format that can do that in order to achieve the full performance.
Flatbuffers was only a suggestion, we currently don't have a pre-templated header available
See links to eCAL samples above 😊
Without knowing your use case I still want to say: Zero-Copy sounds awesome, but what you rather should optimize for is performance, independent from where it comes from. As long as your messages are not "that big", one additional copy will not take enough time to be noticeable and you can often achieve more effect by optimizing other parts of your code (e.g. the protobuf pitfalls I mentioned). Our applications ran just fine in the past without zero copy. |
Beta Was this translation helpful? Give feedback.
-
In theory, Github is accessible in China, in practice , it's slow. The more effective way is using VPN or mirror websites.
I will try this according to the examples.
Understood and agreened. I will do the test-oriented-optimization for algorithm-based-applications rather than sticking to the zero copy tech. Thank you for the help! |
Beta Was this translation helpful? Give feedback.
-
|
Hi @ZhenshengLee first of all thank you for all the effort - great ! I checked the eCAL binding of the performance test and there are at least two major issues from performance perspective. First issue is discussed previously, the message protocol needs some extra time to serialize and deserialize the content. But besides this there is another issue (and maybe we need to extend the eCAL API here). If you use the The only way to avoid copies on the receiver side for raw data is to use a callback. I adapted the eCAL performance interface to use a simple callback method and I bypassed Protobuf by using some ugly casting writing and reading the needed time stamp and id into a bytes char array. Can you please give it a try ? There is a lot to improve .. but just for getting an idea .. // Copyright 2022 zhenshenglee, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef COMMUNICATION_ABSTRACTIONS__ECAL_COMMUNICATOR_HPP_
#define COMMUNICATION_ABSTRACTIONS__ECAL_COMMUNICATOR_HPP_
#include <ecal/ecal.h>
#include <string>
#include <memory>
#include "communicator.hpp"
#include "resource_manager.hpp"
#include "../experiment_configuration/qos_abstraction.hpp"
namespace performance_test
{
/// Translates abstract QOS settings to specific QOS settings for eCAL.
class EcalQOSAdapter
{
public:
/**
* \brief Constructs the QOS adapter.
* \param qos The abstract QOS settings the adapter should use to derive the implementation specific QOS settings.
*/
explicit EcalQOSAdapter(const QOSAbstraction qos)
: m_qos(qos)
{}
/// Returns derived eCAL reliability setting from the stored abstract QOS setting.
inline eCAL::QOS::eQOSPolicy_Reliability reliability() const
{
if (m_qos.reliability == QOSAbstraction::Reliability::BEST_EFFORT) {
return eCAL::QOS::eQOSPolicy_Reliability::best_effort_reliability_qos;
} else if (m_qos.reliability == QOSAbstraction::Reliability::RELIABLE) {
return eCAL::QOS::eQOSPolicy_Reliability::reliable_reliability_qos;
} else {
throw std::runtime_error("Unsupported QOS!");
}
}
/// Returns derived eCAL history policy setting from the stored abstract QOS setting.
inline eCAL::QOS::eQOSPolicy_HistoryKind history_kind() const
{
if (m_qos.history_kind == QOSAbstraction::HistoryKind::KEEP_ALL) {
return eCAL::QOS::eQOSPolicy_HistoryKind::keep_all_history_qos;
} else if (m_qos.history_kind == QOSAbstraction::HistoryKind::KEEP_LAST) {
return eCAL::QOS::eQOSPolicy_HistoryKind::keep_last_history_qos;
} else {
throw std::runtime_error("Unsupported QOS!");
}
}
/// Returns derived eCAL history depth setting from the stored abstract QOS setting.
int32_t history_depth() const
{
if (m_qos.history_kind == QOSAbstraction::HistoryKind::KEEP_LAST) {
return static_cast<int32_t>(m_qos.history_depth);
} else if (m_qos.history_kind == QOSAbstraction::HistoryKind::KEEP_ALL) {
// Keep all, keeps all. No depth required, but setting to dummy value.
return 1;
} else {
throw std::runtime_error("Unsupported QOS!");
}
}
private:
const QOSAbstraction m_qos;
};
/**
* \brief The plugin for eCAL.
* \tparam Msg The msg type to use.
*/
template<class Msg>
class EcalCommunicator : public Communicator
{
public:
/// The data type to use.
using DataType = typename Msg::EcalType;
/// Constructor which takes a reference \param lock to the lock to use.
explicit EcalCommunicator(SpinLock & lock)
: Communicator(lock),
m_publisher(nullptr),
m_subscriber(nullptr)
{
auto hz = static_cast<double>(this->m_ec.rate());
auto period_ms = 1000.0 / hz;
this->m_timeout_ms = std::max(10 * period_ms, 100.0);
}
/**
* \brief Publishes the provided data.
*
* The first time this function is called it also creates the publisher.
* Further it updates all internal counters while running.
* \param data The data to publish.
* \param time The time to fill into the data field.
*/
void publish(std::int64_t time)
{
if (!m_publisher)
{
const EcalQOSAdapter qos(m_ec.qos());
ResourceManager::get().init_ecal_runtime();
eCAL::QOS::SWriterQOS writerQos;
writerQos.history_kind = qos.history_kind();
writerQos.reliability = qos.reliability();
writerQos.history_kind_depth = qos.history_depth();
m_publisher = std::unique_ptr<eCAL::CPublisher>(
new eCAL::CPublisher(m_ec.topic_name()));
// https://github.com/ZhenshengLee/performance_test/issues/1
m_publisher->SetQOS(writerQos);
// initialize message layout
init_msg();
}
// set number of publisher memory buffers to improve performance
// https://github.com/ZhenshengLee/performance_test/issues/1
m_publisher->ShmSetBufferCount(1);
if (m_ec.is_zero_copy_transfer())
{
// enable zero copy mode
m_publisher->ShmEnableZeroCopy(1);
}
else
{
// disable zero copy mode
m_publisher->ShmEnableZeroCopy(0);
}
lock();
write_msg(m_bytes.data(), time, next_sample_id());
increment_sent(); // We increment before publishing so we don't have to lock twice.
unlock();
m_publisher->Send(m_bytes.data(), m_bytes.size());
}
/**
* \brief Reads received data.
*
* The first time this function is called it also creates the subscriber.
* In detail this function:
* * Reads samples.
* * Verifies that the data arrived in the right order, chronologically and also
* consistent with the publishing order.
* * Counts received and lost samples.
* * Calculates the latency of the samples received and updates the statistics
accordingly.
*/
// subscriber callback function
void on_receive(const struct eCAL::SReceiveCallbackData* data_)
{
read_msg(static_cast<char*>(data_->buf));
gSetEvent(m_event);
}
void update_subscription()
{
if (!m_subscriber)
{
const EcalQOSAdapter qos(m_ec.qos());
ResourceManager::get().init_ecal_runtime();
eCAL::QOS::SReaderQOS ReaderQos;
ReaderQos.history_kind = qos.history_kind();
ReaderQos.reliability = qos.reliability();
ReaderQos.history_kind_depth = qos.history_depth();
m_subscriber = std::unique_ptr<eCAL::CSubscriber>(
new eCAL::CSubscriber(m_ec.topic_name()));
// https://github.com/ZhenshengLee/performance_test/issues/1
m_subscriber->SetQOS(ReaderQos);
m_subscriber->AddReceiveCallback(std::bind(&EcalCommunicator::on_receive, this, std::placeholders::_2));
eCAL::gOpenEvent(&m_event);
}
// did we get new receives ?
if(gWaitForEvent(m_event, m_timeout_ms))
{
lock();
if (m_prev_timestamp >= m_rec_time)
{
throw std::runtime_error(
"Data consistency violated. Received sample with not strictly "
"older timestamp. Time diff: " + std::to_string(
m_rec_time - m_prev_timestamp) + " Data Time: " +
std::to_string(m_rec_time)
);
}
if (m_ec.roundtrip_mode() == ExperimentConfiguration::RoundTripMode::RELAY)
{
unlock();
publish(m_rec_time);
lock();
}
else
{
m_prev_timestamp = m_rec_time;
update_lost_samples_counter(m_rec_id);
add_latency_to_statistics(m_rec_time);
increment_received();
}
unlock();
}
}
/// Returns the data received in bytes.
std::size_t data_received()
{
return num_received_samples() * sizeof(DataType);
}
private:
int m_timeout_ms = 0;
std::int64_t m_rec_time = 0;
std::uint64_t m_rec_id = 0;
std::vector<char> m_bytes;
std::unique_ptr<eCAL::CPublisher> m_publisher;
std::unique_ptr<eCAL::CSubscriber> m_subscriber;
eCAL::EventHandleT m_event;
void init_msg()
{
DataType msg;
auto num_elements = msg.msg_array_size();
m_bytes.resize(static_cast<size_t>(num_elements * 4));
}
void read_msg(char* data)
{
auto int64_ptr = reinterpret_cast<std::int64_t*>(data);
m_rec_time = *int64_ptr;
int64_ptr++;
auto uint64_ptr = reinterpret_cast<std::uint64_t*>(int64_ptr);
m_rec_id= *uint64_ptr;
}
void write_msg(char* data, std::int64_t time, std::uint64_t id)
{
auto int64_ptr = reinterpret_cast<std::int64_t*>(data);
*int64_ptr = time;
int64_ptr++;
auto uint64_ptr = reinterpret_cast<std::uint64_t*>(int64_ptr);
*uint64_ptr = id;
}
};
} // namespace performance_test
#endif // COMMUNICATION_ABSTRACTIONS__ECAL_COMMUNICATOR_HPP_ |
Beta Was this translation helpful? Give feedback.
-
|
I add some comments and made some cleanups- Please use that version for testing. On my machine I got an improvement of factor 20 for none zero copy and factor 35 for zero copy ! // Copyright 2022 zhenshenglee, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef COMMUNICATION_ABSTRACTIONS__ECAL_COMMUNICATOR_HPP_
#define COMMUNICATION_ABSTRACTIONS__ECAL_COMMUNICATOR_HPP_
#include <ecal/ecal.h>
#include <string>
#include <memory>
#include "communicator.hpp"
#include "resource_manager.hpp"
#include "../experiment_configuration/qos_abstraction.hpp"
namespace performance_test
{
/// Translates abstract QOS settings to specific QOS settings for eCAL.
class EcalQOSAdapter
{
public:
/**
* \brief Constructs the QOS adapter.
* \param qos The abstract QOS settings the adapter should use to derive the implementation specific QOS settings.
*/
explicit EcalQOSAdapter(const QOSAbstraction qos)
: m_qos(qos)
{}
/// Returns derived eCAL reliability setting from the stored abstract QOS setting.
inline eCAL::QOS::eQOSPolicy_Reliability reliability() const
{
if (m_qos.reliability == QOSAbstraction::Reliability::BEST_EFFORT) {
return eCAL::QOS::eQOSPolicy_Reliability::best_effort_reliability_qos;
} else if (m_qos.reliability == QOSAbstraction::Reliability::RELIABLE) {
return eCAL::QOS::eQOSPolicy_Reliability::reliable_reliability_qos;
} else {
throw std::runtime_error("Unsupported QOS!");
}
}
/// Returns derived eCAL history policy setting from the stored abstract QOS setting.
inline eCAL::QOS::eQOSPolicy_HistoryKind history_kind() const
{
if (m_qos.history_kind == QOSAbstraction::HistoryKind::KEEP_ALL) {
return eCAL::QOS::eQOSPolicy_HistoryKind::keep_all_history_qos;
} else if (m_qos.history_kind == QOSAbstraction::HistoryKind::KEEP_LAST) {
return eCAL::QOS::eQOSPolicy_HistoryKind::keep_last_history_qos;
} else {
throw std::runtime_error("Unsupported QOS!");
}
}
/// Returns derived eCAL history depth setting from the stored abstract QOS setting.
int32_t history_depth() const
{
if (m_qos.history_kind == QOSAbstraction::HistoryKind::KEEP_LAST) {
return static_cast<int32_t>(m_qos.history_depth);
} else if (m_qos.history_kind == QOSAbstraction::HistoryKind::KEEP_ALL) {
// Keep all, keeps all. No depth required, but setting to dummy value.
return 1;
} else {
throw std::runtime_error("Unsupported QOS!");
}
}
private:
const QOSAbstraction m_qos;
};
/**
* \brief The plugin for eCAL.
* \tparam Msg The msg type to use.
*/
template<class Msg>
class EcalCommunicator : public Communicator
{
public:
/// The data type to use.
using DataType = typename Msg::EcalType;
/// Constructor which takes a reference \param lock to the lock to use.
explicit EcalCommunicator(SpinLock & lock)
: Communicator(lock),
m_publisher(nullptr),
m_subscriber(nullptr)
{
auto hz = static_cast<double>(this->m_ec.rate());
auto period_ms = 1000.0 / hz;
this->m_timeout_ms = std::max(10 * period_ms, 100.0);
}
/**
* \brief Publishes the provided data.
*
* The first time this function is called it also creates the publisher.
* Further it updates all internal counters while running.
* \param data The data to publish.
* \param time The time to fill into the data field.
*/
void publish(std::int64_t time)
{
if (!m_publisher)
{
const EcalQOSAdapter qos(m_ec.qos());
ResourceManager::get().init_ecal_runtime();
eCAL::QOS::SWriterQOS writerQos;
writerQos.history_kind = qos.history_kind();
writerQos.reliability = qos.reliability();
writerQos.history_kind_depth = qos.history_depth();
// create publisher
m_publisher = std::unique_ptr<eCAL::CPublisher>(new eCAL::CPublisher(m_ec.topic_name()));
// set QOS
m_publisher->SetQOS(writerQos);
// set number of used publisher memory buffer
m_publisher->ShmSetBufferCount(1);
if (m_ec.is_zero_copy_transfer())
{
// enable zero copy mode
m_publisher->ShmEnableZeroCopy(1);
}
else
{
// disable zero copy mode
m_publisher->ShmEnableZeroCopy(0);
}
// initialize message layout
init_msg();
}
// write time and id into message
lock();
write_msg(m_bytes.data(), time, next_sample_id());
increment_sent(); // We increment before publishing so we don't have to lock twice.
unlock();
// publish message
m_publisher->Send(m_bytes.data(), m_bytes.size());
}
/**
* \brief Reads received data.
*
* The first time this function is called it also creates the subscriber.
* In detail this function:
* * Reads samples.
* * Verifies that the data arrived in the right order, chronologically and also
* consistent with the publishing order.
* * Counts received and lost samples.
* * Calculates the latency of the samples received and updates the statistics
accordingly.
*/
// subscriber callback function
void on_receive(const struct eCAL::SReceiveCallbackData* data_)
{
// read time and id out of the received buffer
read_msg(static_cast<char*>(data_->buf), m_rec_time, m_rec_id);
// signal update_subscription to process
gSetEvent(m_event);
}
void update_subscription()
{
if (!m_subscriber)
{
const EcalQOSAdapter qos(m_ec.qos());
ResourceManager::get().init_ecal_runtime();
eCAL::QOS::SReaderQOS ReaderQos;
ReaderQos.history_kind = qos.history_kind();
ReaderQos.reliability = qos.reliability();
ReaderQos.history_kind_depth = qos.history_depth();
// create subscriber
m_subscriber = std::unique_ptr<eCAL::CSubscriber>(new eCAL::CSubscriber(m_ec.topic_name()));
// set QOS
m_subscriber->SetQOS(ReaderQos);
// add receive callback
m_subscriber->AddReceiveCallback(std::bind(&EcalCommunicator::on_receive, this, std::placeholders::_2));
// create sync event
eCAL::gOpenEvent(&m_event);
}
// did we get new receives ?
if(gWaitForEvent(m_event, m_timeout_ms))
{
lock();
if (m_prev_timestamp >= m_rec_time)
{
throw std::runtime_error(
"Data consistency violated. Received sample with not strictly "
"older timestamp. Time diff: " + std::to_string(
m_rec_time - m_prev_timestamp) + " Data Time: " +
std::to_string(m_rec_time)
);
}
if (m_ec.roundtrip_mode() == ExperimentConfiguration::RoundTripMode::RELAY)
{
unlock();
publish(m_rec_time);
lock();
}
else
{
m_prev_timestamp = m_rec_time;
update_lost_samples_counter(m_rec_id);
add_latency_to_statistics(m_rec_time);
increment_received();
}
unlock();
}
}
/// Returns the data received in bytes.
std::size_t data_received()
{
return num_received_samples() * msg_size();
}
private:
int m_timeout_ms = 0;
std::int64_t m_rec_time = 0;
std::uint64_t m_rec_id = 0;
std::vector<char> m_bytes;
std::unique_ptr<eCAL::CPublisher> m_publisher;
std::unique_ptr<eCAL::CSubscriber> m_subscriber;
eCAL::EventHandleT m_event;
void init_msg()
{
m_bytes.resize(msg_size());
}
void read_msg(char* data, std::int64_t& time, std::uint64_t& id)
{
auto int64_ptr = reinterpret_cast<std::int64_t*>(data);
time = *int64_ptr;
int64_ptr++;
auto uint64_ptr = reinterpret_cast<std::uint64_t*>(int64_ptr);
id= *uint64_ptr;
}
void write_msg(char* data, std::int64_t time, std::uint64_t id)
{
auto int64_ptr = reinterpret_cast<std::int64_t*>(data);
*int64_ptr = time;
int64_ptr++;
auto uint64_ptr = reinterpret_cast<std::uint64_t*>(int64_ptr);
*uint64_ptr = id;
}
size_t msg_size()
{
DataType msg;
auto num_elements = msg.msg_array_size();
const auto single_element_size(4);
return(num_elements * single_element_size);
}
};
} // namespace performance_test
#endif // COMMUNICATION_ABSTRACTIONS__ECAL_COMMUNICATOR_HPP_ |
Beta Was this translation helpful? Give feedback.
-
|
@rex-schilasky with this pr, you can test with ECAL_RAW(for rosidl msg definitions) and ECAL_PROTO(for proto msg definitions).
An invitation for review has been sent. |
Beta Was this translation helpful? Give feedback.
-
|
@ZhenshengLee thank you, that looks much better now :-). I made an initial check on your pr and I would like to adapt the protobuf version to use the same callback logic like the raw variant. Then we would get a better comparison between raw and protobuf encoding. |
Beta Was this translation helpful? Give feedback.
-
Thank you for your help! And I must point that there is data time consistency problem in the callback logic, which is not happen in the waiset logic. |
Beta Was this translation helpful? Give feedback.
-
|
Okay I will check that consistency too but first I will adapt the protobuf variant. I would do the work on your existing branch, right ? May I adapt the protobuf messages too ? I would change from |
Beta Was this translation helpful? Give feedback.
-
I suggest you create a new branch based on
Yes you can. |
Beta Was this translation helpful? Give feedback.
-
|
I changed all proto2 definitions to proto3 ones now and used fixed types instead variant encoded ones. The ECAL_PROTO version is working with a callback logic now but stills makes a copy of the message in the callback (like the raw variant btw. too). This needs to adapted next. See this PR ZhenshengLee/performance_test#5. |
Beta Was this translation helpful? Give feedback.
-
|
My adaptions are done. Please retest - looking forward to updated results for |
Beta Was this translation helpful? Give feedback.
-
|
@rex-schilasky Thank you for your coding! the performance of your version improves a lot!
the data time consistency problem happens very quick and often, It must be fixed for automatic test in https://github.com/ZhenshengLee/performance_test/tree/outdoor/master/performance_report |
Beta Was this translation helpful? Give feedback.
-
|
@rex-schilasky see automatic test results in here https://zhenshenglee.github.io/ros2_jetson_benchmarks/benchmark_results/galactic/pc_ros2_galactic_v5.13.0-41-generic_amd64/dds_compare/ |
Beta Was this translation helpful? Give feedback.
-
|
Thinking it's time for supporting zero-copy for rclcpp in using rmw_ecal! Tracking this issue in https://github.com/continental/rmw_ecal/issues/45 |
Beta Was this translation helpful? Give feedback.
-
|
Yes, but lets first fix all issues for that test suite. Then maybe we can create the fastest RMW for ROS2 :-). There is one upcoming new feature (maybe for 5.11) that allows parallel reading for ecal shm (zero copy and none zero copy). That will improve the performance for 1:N connections a lot under special conditions (slow user callback processing in combination with zero copy for example). For now we have exclusive read/write locks and perform best for 1:1 connections. But this benchmark suite is a great help to check and compare all variants of shm communication. |
Beta Was this translation helpful? Give feedback.
-
|
@ZhenshengLee I replaced the event logic with a conditional variable one. Now I hope the consistency issue is fixed. I could not reproduce it anymore. Please recheck. |
Beta Was this translation helpful? Give feedback.
-
|
recheck done. issues all fixed. pr merged. |
Beta Was this translation helpful? Give feedback.
-
|
@rex-schilasky |
Beta Was this translation helpful? Give feedback.
-
Need a performance benchmarks tool?
Hi everyone, I just added ability of support of eCAL to a benchmarks tool for robotics middleware from apex.ai company, which is open source at
https://github.com/ZhenshengLee/performance_test
Ability with the performance_test
with this tool you can
use the tool like
mkdir experiment ./install/performance_test/lib/performance_test/perf_test --communication CycloneDDS --msg Array1k --rate 100 --topic test_topic --max-runtime 30 --logfile experiment/logeCAL support
-DPERFORMANCE_TEST_ECAL_ENABLED=ON-c ECAL--zero-copy): yesps:
eCAL::protobuf::CPublisheris used.usage
test result example
screenshot
limitations and issues
currently issues are found with eCAL at ZhenshengLee/performance_test#1 and ZhenshengLee/performance_test#2
related disscusions
#625
Beta Was this translation helpful? Give feedback.
All reactions