= QCG-Notification Benchmarks = [[Include(https://apps.man.poznan.pl/trac/qcg-notification/wiki/Changelog#version2.6.426Mar2012)]] The QCG-Notification performance was compared to the performance of two other services implementing brokered version of WS-Notification specification. These were Apache !ServiceMix (version 3.3.1) and IBM !WebSphere Application Server (version 7.0). A reliable performance tests of the notification systems are difficult to realise. Note that the proceeding time of a single, small message is highly short, difficult to correct measurement and highly depends on many aspects, such as machine configuration, underlying best effort transport protocols or network protocols. To overcome this problem, the time was measured not on the basis of a single send of a notification, but on the basis of multiple sends (called here bunch) assumed as an elementary event. Taking into account these objectives as well as the fact that the tested notification systems are different: each system provides a set of specific functions that may be unavilable in the another systems (for example, !ServiceMix doesn’t provide support for Full topic dialect), the decision was to test only the most common features and focus on key scenarios. The elementary events were performed many times and the received results were averaged. == Testbed == The testbed consisted of two homogenous machines connected over the 1Gb Ethernet (see the attached figure). The first machine was used to host the lightweight versions of notification systems clients, that are Publisher and !NotificationConsumer, while the second machine was dedicated for the three tested notification systems and additionally for the another instance of !NotificationConsumer to allow simple tests. [[Image(tests-deployment.png, center, width=540px)]] == Test 1 - Notification Delivery without Active Subscriptions == The first test concerned the measurement of the time of sending a bunch of notifications (however each notification is sent separately) while there were no active subscriptions in the tested system. That means that the time was counted on the Publisher side and the notifications were not forwarded by the brokers as there were any Notification Consumers interested in receiving notifications. ==== Main facts ==== * Scenario's draft: Publisher -> Notification Broker * Time measurement: on Publisher's side * Filtering based on: topics * Notification dialect: Simple * Notification payload: about 320 bytes * Number of notifications in one bunch: 1000 ==== Notes ==== ''Pros:'' * Possibility to compare performance of the systems in the most basic, but typical scenario, where notifications are not forwarded to Notification Consumers. * The delay imposed by the notification systems as well as the network may be easily measured by comparison to the times of sending notifications between lightweight Publisher and Notification Consumer programs. ''Cons:'' * The Publisher installed only on a single machine. * The notification services in a default configuration and only marginally loaded (no subscriptions). * The measurement of time on the Publisher site may be unreliable because the service can schedule the processing of notifications for future. ==== Results ==== [[Image(QCG-Notification-Notify-Test1.png, center, width=540px)]] == Test 2 - Notification Delivery with Active Subscriptions == In this test the measured value was the time of forwarding notifications from Publisher to Notification Consumer via different systems. In contrast to the previous test, here the tested systems utilized Subscriptions and on their basis determined where to send a certain notification. The next importand difference was the move of the finish time measurement from Publisher to Notification Consumer. ==== Main facts ==== * Scenario's draft: Publisher -> Notification Broker -> Notification Consumer * Time measurement: on Publisher's side (start time) and on Notification Consumer's side (finish time) * Filtering based on: topics * Notification dialect: Simple * Notification payload: about 320 bytes * Number of notifications in one bunch: 1000 ==== Notes ==== ''Pros:'' * Possibility to compare performance of the systems in the typical scenario that takes into account notification forwarding to Notification Consumers. * The time is measured not only by Publisher but also by Notification Consumer which gives more precise results of processing time. ''Cons:'' * The Publisher and Notification Consumer programs installed only on a single, the same machine. * The notification services in a default configuration and marginally loaded (only several subscriptions). * !WebSphere Application Server concatenates received messages if they are forwarded to the same Notification Consumer - although in general it improves the performance, sometimes it may impose delays in sending to consumers and improper results. Nevertheless this point was practically neutralized thanks to measuring the time of large amount of elementary operations. ==== Results ==== [[Image(QCG-Notification-Notify-Test2.png, center, width=340px)]] == Test 3 - Subscribing == The aim of the third benchmark was the comparison of the times of creating subscriptions in the tested systems. In the Subscribing test, a lightweight Subscriber program created the same number of the same subscriptions in each system. Similarly to the previous tests, the time, which was measured by the Subscriber program, covered a bunch of invokes of a single Subscribe operation. ==== Main facts ==== * Scenario's draft: Subscriber -> Notification Broker * Time measurement: by Subscriber * Filtering based on: topics * Subscription dialect: Simple * !SubscribeRequest payload: about 300 bytes * !SubscribeResponse payload: about 280 bytes * Number of Subscribe operations in one bunch: 100 ==== Notes ==== ''Pros:'' * Possibility to compare the time of creating common subscriptions in the tested systems. ''Cons:'' * Only one Subscriber program. * The notification services in a default configuration; no other operations invoked while subscribing - poorly realistic situation. ==== Results ==== [[Image(QCG-Notification-Subscribe-Test1.png, center, width=340px)]]