Directing two queue to one node

[arsiboo]

I'm encountering an issue in defining the q_args for 'num_servers' in case of connecting two queues to the same node. In my case each node has number of servers. Let's say two queues (labeled '2' and '3') arrive to the same node and the node's number of servers is '5'. Thus the 'num_servers' for queue '2' is set to '5', and 'num_servers' for queue '3' is set to '5'. But the thing is that I want both queues total 'num_servers' to be '5', not individually. Is this possible? How should I define the q_args in this case?

[djordon]

I think I understand what you're asking, but let me repeat it back to make sure that I got it.

Suppose we have a simple graph with three nodes named nodes 1, 2, and 3, where there is an edge from node 1 and 3, and from node 2 and 3. We want to have this network set up such that the total number of servers leading into node 3 is 5. So, if edge 1->3 has 4 agents being serviced, there can only be one agent being serviced on edge 2->3. Is this correct?

This isn't easy to do. If I were trying to do this, I'd subclass QueueServer and have this new class use a shared state. Here is a rough (and probably incorrect) sketch of what I'm thinking:

import queueing_tool as qt


class SharedQueueServer(qt.QueueServer):
    def __init__(self, shared_server_state: list[int], **kwargs):
        super().__init__(**kwargs)
        self.shared_server_state = shared_server_state
        self.total_num_servers = kwargs.get("num_servers", 1)

    @property
    def num_servers(self):
        return self.total_num_servers - self.shared_server_state[0]

    @num_servers.setter
    def num_servers(self, value):
        self.total_num_servers = value

    def next_event(self):
        next_event_type = self.next_event_description()
        # Event type 2 is a departure
        if next_event_type == 2:
            self.shared_server_state[0] += 1
            super().next_event(self)

        # Event type 1 is an arrival
        elif next_event_type == 1:
            self.shared_server_state[0] -= 1
            super().next_event(self)

# Make an adjacency list
adja_list = {0 : [2], 1: [2]}

# This says edges 0->2 and 1->2 will use the q_class with key 1
edge_type = {0: {2: 1}, 1: {2: 1}}

# Creates a networkx directed graph using the adjacency list and edge list
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_type)

# Make a mapping between the edge types and the queue classes that sit on each
# edge. Do not use 0 as a key, it's used to map to NullQueues.
q_classes = {1: SharedQueueServer}

shared_state = [0]
q_args = {
    1: {'shared_server_state': shared_state, 'num_servers': 5},
}

qn = qt.QueueNetwork(g=g, q_classes=q_classes, q_args=q_args)

I'm not sure the above captures what you want, or if it even works! It seems tricky to get right. Moveover, even if the sketch above is correct, it won't actually work until I patch a bug related to the number of servers (which should ship this week). The bug is here #64.

Anyway, hope this helps!

[arsiboo]

Thanks a lot for a very quick reply and tip. Then I will wait for the update.

[arsiboo]

Hi,

I saw you merged it but I don't know how to get the latest version. I usually use pip to install packages.

[djordon]

I haven't cut the release yet. I'm still on track to ship that fix and one or two other changes this week. I'll post here when I do.

[arsiboo]

Thank you

[djordon]

@arsiboo the new version of queueing-tool has been published.

[arsiboo]

Thanks again.

[arsiboo]

I tried to use the SharedQueueServer and I encountered an error in simulation time when running the simulation:

"TypeError: 'int' object is not subscriptable"

[djordon]

I'm not sure how you got that error. I just ran the code I posted above and got a different error (I forgot to return the agent when there was a departure). After fixing that error and plugging a couple of lingering logic bugs I think it works as intended.

Specifically, I got the sign wrong for how to update the shared state when there was an arrival or a departure, I updated on arrivals too frequently, I didn't return the departure, and I called super().next_event incorrectly. Here is the diff:

@@ -19,13 +19,15 @@ class SharedQueueServer(qt.QueueServer):
         next_event_type = self.next_event_description()
         # Event type 2 is a departure
         if next_event_type == 2:
-            self.shared_server_state[0] += 1
-            super().next_event(self)
+            self.shared_server_state[0] -= 1
+            return super().next_event()
 
         # Event type 1 is an arrival
         elif next_event_type == 1:
-            self.shared_server_state[0] -= 1
-            super().next_event(self)
+            if self.num_system - len(self.queue) < self.num_servers:
+                self.shared_server_state[0] += 1
+            super().next_event()
 
 # Make an adjacency list

Here is the updated code

import queueing_tool as qt


class SharedQueueServer(qt.QueueServer):
    def __init__(self, shared_server_state: list[int], **kwargs):
        super().__init__(**kwargs)
        self.shared_server_state = shared_server_state
        self.total_num_servers = kwargs.get("num_servers", 1)

    @property
    def num_servers(self):
        return self.total_num_servers - self.shared_server_state[0]

    @num_servers.setter
    def num_servers(self, value):
        self.total_num_servers = value

    def next_event(self):
        next_event_type = self.next_event_description()
        # Event type 2 is a departure
        if next_event_type == 2:
            self.shared_server_state[0] -= 1
            return super().next_event()

        # Event type 1 is an arrival
        elif next_event_type == 1:
            # We only use a server if there is capacity.
            if self.num_system - len(self.queue) < self.num_servers:
                self.shared_server_state[0] += 1
            super().next_event()

# Make an adjacency list
adja_list = {0 : [2], 1: [2]}

# This says edges 0->2 and 1->2 will use the q_class with key 1
edge_type = {0: {2: 1}, 1: {2: 1}}

# Creates a networkx directed graph using the adjacency list and edge list
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_type)

# Make a mapping between the edge types and the queue classes that sit on each
# edge. Do not use 0 as a key, it's used to map to NullQueues.
q_classes = {1: SharedQueueServer}

shared_state = [0]
q_args = {
    1: {'shared_server_state': shared_state, 'num_servers': 5},
}

qn = qt.QueueNetwork(g=g, q_classes=q_classes, q_args=q_args)

Hopefully this works as you intended.

[arsiboo]

It works fine. Thanks.

[djordon]

What code did you run?

…

On Mon, Oct 10, 2022, 8:12 AM m1karmida ***@***.***> wrote: I tried to use the SharedQueueServer and I encountered an error in simulation time when running the simulation: "TypeError: 'int' object is not subscriptable" Hi, I also needed to use the same code for drawing my queueuing network, but i occured in the same error. How do you fixed it? — Reply to this email directly, view it on GitHub <#76 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AB534UC42NSYHYDOHYRP7KTWCQB2HANCNFSM6AAAAAAQ36UTZE> . You are receiving this because you commented.Message ID: ***@***.***>

[arsiboo]

The class that you built here but with my network as an input.

[djordon]

The class that you built here but with my network as an input.

Would you mind posting a stacktrace of the exception, so that I can see where you hit the error?

[arsiboo]

The error was showing on the class when you first introduced the code, not the edited one. Just to make sure I understood you correctly, you want to see the error and the code which produces the error right?

[djordon]

Ohhh whoops I misunderstood. I saw this on my phone and thought there was a new error that my new code didn't address. Never mind!