Benchmarking UiPath Performance using Multiple Bots
In this second part of benchmarking UiPath performance, we will see how UiPath reduces the execution time of processing several huge files. Learn how to implement multiple bots and use them at the same time to execute a single process.
It is obvious from our previous case study, that the performance of Uipath automation is super-efficient and beneficial.
In our previous case study, we benchmarked the performance of uipath by processing huge files on various system configurations. We saw different approaches to improve the performance of Uipath. We also saw how to reduce the execution time for processing a single file.
The execution time increases when we process more than one file i.e if one huge file takes a minute to complete the process, then for 3 files the execution time will be 3 times the process taken for one file.
We can handle this situation by using reframework template and by adding queue items to the orchestrator. Orchestrator is a cloud platform dashboard where we can create, manage and organize our robots. We can also create processes, jobs, assets, and queues. To know more about orchestrator, queues and reframework click on the below link.
In the previous case study, we saw how to process one huge file. Now we will see how to process 5 huge files. If we use one bot to process a huge number of files then the time taken will also be more. So we need to process 5 files parallelly in order to reduce the execution time. So in this case study, we will see how to process the huge number of files parallelly using different robots. To do that, we will be using a reframework template, add items to queues and assign multiple bots to process the queue items in the orchestrator.
The above image shows bots that are ready to process the queues.
In the previous iterations, we used a single flowchart for the whole process. Reframework template is the recommended way to process huge files. Reframework template helps the developer to build the process quickly and efficiently. The Reframework template makes use of state machines. There will be four state machines Init, get transaction data, Process transaction and end process. In this process, we will make use of this template.
DISPATCHER AND PERFORMER:
We will be handling two processes, one is dispatcher and another is the performer. Generally, the dispatcher uploads the queue items to the orchestrator and the performer gets the queue items from the orchestrator then processes the queue items.
WORKING OF QUEUES:
We can deploy any number of bots to the orchestrator and make them process the queues parallelly. Generally, the bot process only the queue which has the status new. If the bot completes the queue its status will be set to completed. If the queue fails, then it sets the status as failed. If the bot is processing the queue, then the queue status will be set to in progress. So if one queue is being processed by one bot, then any queue with the status new will be processed by another bot.
Let’s have the same file which we used in the previous iterations. Let’s start with the dispatcher, it uploads the items to the queue. Here we will be using 5 files of the same format. We will upload each file path to the queue and then by using the performer, we can get the file path, in order to process the file.
In dispatcher, we will iterate through each file in the folder in order to get the file path of the file which is to be processed. Now we have to upload those file paths to the queue in the orchestrator. To do that we can make use of for each activity. Inside for each activity, insert add queue times activity. Specify the name of the queue in the queue name property. Now run the dispatcher, after the process gets finished, take a look into the orchestrator queue. Click on view transactions, now you can view all the transactions made.
After dispatcher is executed, you can go to your queues in the orchestrator, and click on view transactions. You can see the uploaded queue items. Now the transaction items with the status new will be executed.
Now in the performer, create a blank sequence and get the file path from the queue using in_TransactionItem.SpecificContent(“ObjectName in queue”).ToString this will give the file path in the queue. Now by using the file path we can process the files. Then use the same process that we used in the previous iterations (ref). Invoke all the sequences and bind the arguments.
From the above image, we can see two bots are processing different transaction items at the same time. The status of the processing items will be set to In Progress.
First, run the dispatcher so it can push queue items to the orchestrator. Then run the performer in both the machines, so the bots will perform only the queues with status new.
Bot 1 has performed 3 files in 42s and bot 2 has performed 2 files in 35s. So the average time taken by this process is 38.5s. While performing 5 files by one bot, it took around 50s. When performing more number of files we can make use of parallel processing by implementing the number of bots in the orchestrator. So now you can see the time difference between how one bot process 5 files and 2 bots processing each file simultaneously.
Therefore when we use multiple bots to process each file simultaneously, the execution process is efficient and also faster respective to the bots we implement.