8 /** A sender. This is a role class, so real senders need to inherit from it.
10 class Sender : private Prio_list_elem
14 /** Receiver-ready callback. Receivers make sure to call this
15 function on waiting senders when they get ready to receive a
16 message from that sender. Senders need to overwrite this interface. */
17 virtual bool ipc_receiver_ready(Receiver *) = 0;
18 virtual void ipc_receiver_aborted() = 0;
19 virtual void modify_label(Mword const *todo, int cnt) = 0;
28 friend class Jdb_thread_list;
38 #include "lock_guard.h"
42 // state requests/manipulation
45 /** Optimized constructor. This constructor assumes that the object storage
47 @param id user-visible thread ID of the sender
48 @param ignored an integer argument. The value doesn't matter and
49 is used just to distinguish this constructor from the
54 Sender::Sender (int /*ignored*/)
60 @return receiver this sender is currently trying to send a message to.
64 Sender::receiver() const
69 /** Set current receiver.
70 @param receiver the receiver we're going to send a message to
74 Sender::set_receiver (Receiver* receiver)
80 unsigned short Sender::sender_prio()
82 return Prio_list_elem::prio();
85 /** Sender in a queue of senders?.
86 @return true if sender has enqueued in a receiver's list of waiting
91 Sender::in_sender_list() const
93 return Prio_list_elem::in_list();
98 Sender::is_head_of(Prio_list const *l) const
99 { return l->head() == this; }
104 Sender::cast(Prio_list_elem *e)
105 { return static_cast<Sender*>(e); }
109 //PROTECTED inline NEEDS [<cassert>, "cpu_lock.h", "lock_guard.h",
110 // Sender::replace_node, Sender::tree_insert]
111 void Sender::sender_enqueue(Prio_list *head, unsigned short prio)
115 Lock_guard<Cpu_lock> guard (&cpu_lock);
116 head->insert(this, prio);
119 //PUBLIC inline NEEDS [<cassert>, "cpu_lock.h", "lock_guard.h",
120 // Sender::remove_tree_elem, Sender::remove_head]
121 PUBLIC template< typename P_LIST >
122 void Sender::sender_dequeue(P_LIST list)
125 if (!in_sender_list())
128 Lock_guard<Cpu_lock> guard (&cpu_lock);
132 // An special version, only to remove the head
133 // this is neccessary if the receiver removes the old know head
134 // after an unsuccessful ipc_receiver_ready.
135 PUBLIC template< typename P_LIST >
136 void Sender::sender_dequeue_head(P_LIST list)
139 if (!in_sender_list())
142 Lock_guard<Cpu_lock> guard (&cpu_lock);
144 if (this == list->head())
148 PROTECTED template<typename P_LIST >
149 void Sender::sender_update_prio(P_LIST list, unsigned short newprio)
151 if(EXPECT_FALSE(sender_prio() == newprio))
154 Lock_guard<Cpu_lock> guard (&cpu_lock);
156 if (!in_sender_list())
159 sender_dequeue(list);
160 sender_enqueue(list, newprio);
164 @param id user-visible thread ID of the sender