Sample Code
1 protected Queue is 2 procedure Enqueue (elt : in Q_Element); 3 -- Insert elt @ the tail end of the queue 4 function First_in_line return Q_Element; 5 -- Return the element at the head of the 6 -- queue, or no_elt. 7 procedure Dequeue; 8 -- If the queue is not empty, remove the 9 -- element at its head 10 end Queue; 11 12 task type Worker; 13 14 task body Worker is 15 elt : Q_Element; -- Element retrieved from queue 16 begin 17 while true loop 18 elt := Queue.First_in_line; -- Get element at head of queue 19 if elt = no_elt then -- Let the task loop until there 20 delay 0.1; -- is something in the queue 21 else 22 Process (elt); -- Process elt. This takes some time 23 Queue.Dequeue; -- Remove element from queue 24 end if; 25 end loop; 26 end Worker;
Comparing and Contrasting Ada’s Protected Function to Java’s (non)synchronized
Java’s safe objects are synchronized objects, which are usually contained in methods that are “synchronized” or “non-synchronized”. For the non-synchronized methods, the safe objects within these methods are mostly considered to be read-only. Whereas in synchronized methods, safe objects can be written and read, but usually have wait loops at the beginning with a certain wait condition (i.e. while (condition) {wait( );}). This wait loop forces the thread to wait until when the condition becomes true, in order to prevent multiple threads from editing the same safe object at the same time. Usually, wait loops located elsewhere in the Java synchronized methods are (uncommon).
Safe objects in Ada are protected objects are in the “protected procedure” or a “protected function”. Unlike the non-synchronized method in Java (where it should be read-only), the protected function in Ada is read-only. Java’s synchronized version has a wait function that stalls a thread, in the Ada’s protected entry (i.e. entry x ( ) when condition is …) is only entered when the condition is true, thus you can have multiple entries where data could manipulate in multiple ways similar to an if-else function. For example, entry x ( ) when condition is true and another one right after could be entry x ( ) when condition is false. Though, this can be expanded to n different conditions, where. With these entries, the barrier is always tested first compared to wait. However, we could requeue (not a subprogram call-thus the tread doesn’t return to the point after the requeue call) on another entry, but it’s uncommon to have them located elsewhere in the program.
Describe what worker does
Workers must get the element (elt) from the first line item in the queue and then loop through the task until there is an element in the queue for which the worker can process the element. The element is stored in the elt array. If there is no element delay the process by 0.1 units of time and keep looping. Once the worker has obtained an element, they can begin processing the element, then we can remove the element from the current queue.
Adapt Queue and work for multiple instances of worker can process data elements
In order for one worker to process each element, we must first do is change “task body worker is” to “protected body worker is” on line 14. Change “elt: Q_Element;” to procedure get (elt: Q_Element) is in order to get the element from the queue on line 15.
Once there is an element in the first inline of the queue, the worker must first dequeue it in order to process it, this should protect the data and allow for another worker to work on the next first inline element. Thus, I would be proposing to switch lines 22 to 23 and 23 to 22. If this isn’t preferred, we can create a new array called work_in_progress where we create a get, put, and remove procedure for this array, which should go before line 22 and then follow my proposed sequence. This will allow the worker to say I got this element, I will work on it, and if all is successful we don’t need to re-add the element back into the queue and delete it from the work_in_progress array, but I don’t want to hold up other workers from working on other elements. However, if the worker says I failed to process this array, please return it back into the queue and add it into the elt array again for another worker to process it. To avoid an endless loop, if an element cannot be processed by three different workers we can create another array to store non-compliant elements in and call Dequeue on the main elt array. However, we can simply and only switch lines 22 and 23 with each other if and only if this change shows that processing the element could never fail.
In Queue line 2 must have entries, for instance “entry Enqueue (elt : in Q_Element) when count >= 0 is … end Enqueue”, to allow for waiting until there are actually element to be added from the array elt. Doing entries in Queue, would be eliminating the need for the while true loop to search if there is an elt in the first of the line in lines 19, 20, & 21. Thus, we are making our conditions check first rather than later on in the code. Similarly, we can do a change to line 7 to “entry Dequeue (elt : in Q_Element) when count > 0 is … end Dequeue”, to allow for waiting until there is actually element for deletion from the array elt. Though this is more for an efficiency issue and allows for the worker to say I got this element and it’s ok to delete from the queue. With all these changes we must make sure that on line 18 we must make sure we are pulling an element from an elt array.
The loop where instances of workers wait is crude
Line 18 and 23 can be combined with Queue.Pop (elt) above the if-statement in on line 18, to avoid the crude loop where threads of workers wait for something in the queue. The pop allows for no “busy waiting”. But, we must create a procedure in Queue called procedure pop which returns a query on the first line item on the array elt and removes it.
Dr. Skylar (Sky) Hernandez 