1use loom::{
12 futures::AtomicTask,
13 sync::{
14 atomic::{AtomicPtr, AtomicUsize},
15 CausalCell,
16 },
17 yield_now,
18};
19
20use futures::Poll;
21
22use std::fmt;
23use std::ptr::{self, NonNull};
24use std::sync::atomic::Ordering::{self, AcqRel, Acquire, Relaxed, Release};
25use std::sync::Arc;
26use std::usize;
27
28pub struct Semaphore {
30 state: AtomicUsize,
33
34 head: CausalCell<NonNull<WaiterNode>>,
36
37 rx_lock: AtomicUsize,
39
40 stub: Box<WaiterNode>,
42}
43
44#[derive(Debug)]
56pub struct Permit {
57 waiter: Option<Arc<WaiterNode>>,
58 state: PermitState,
59}
60
61#[derive(Debug)]
63pub struct AcquireError(());
64
65#[derive(Debug)]
67pub struct TryAcquireError {
68 kind: ErrorKind,
69}
70
71#[derive(Debug)]
72enum ErrorKind {
73 Closed,
74 NoPermits,
75}
76
77#[derive(Debug)]
79struct WaiterNode {
80 state: AtomicUsize,
84
85 task: AtomicTask,
87
88 next: AtomicPtr<WaiterNode>,
90}
91
92#[derive(Copy, Clone)]
103struct SemState(usize);
104
105#[derive(Debug, Copy, Clone, Eq, PartialEq)]
107enum PermitState {
108 Idle,
110
111 Waiting,
114
115 Acquired,
117}
118
119#[derive(Debug, Copy, Clone, Eq, PartialEq)]
121#[repr(usize)]
122enum NodeState {
123 Idle = 0,
127
128 Queued = 1,
135
136 QueuedWaiting = 2,
138
139 Assigned = 3,
142
143 Closed = 4,
145}
146
147impl Semaphore {
150 pub fn new(permits: usize) -> Semaphore {
156 let stub = Box::new(WaiterNode::new());
157 let ptr = NonNull::new(&*stub as *const _ as *mut _).unwrap();
158
159 debug_assert!(ptr.as_ptr() as usize & NUM_FLAG == 0);
161
162 let state = SemState::new(permits, &stub);
163
164 Semaphore {
165 state: AtomicUsize::new(state.to_usize()),
166 head: CausalCell::new(ptr),
167 rx_lock: AtomicUsize::new(0),
168 stub,
169 }
170 }
171
172 pub fn available_permits(&self) -> usize {
174 let curr = SemState::load(&self.state, Acquire);
175 curr.available_permits()
176 }
177
178 fn poll_permit(&self, mut permit: Option<&mut Permit>) -> Poll<(), AcquireError> {
180 use futures::Async::*;
181
182 let mut curr = SemState::load(&self.state, Acquire);
184
185 debug!(" + poll_permit; sem-state = {:?}", curr);
186
187 let mut maybe_strong: Option<NonNull<WaiterNode>> = None;
191
192 macro_rules! undo_strong {
193 () => {
194 if let Some(waiter) = maybe_strong {
195 let waiter = unsafe { Arc::from_raw(waiter.as_ptr()) };
200 waiter.revert_to_idle();
201 }
202 };
203 }
204
205 loop {
206 let mut next = curr;
207
208 if curr.is_closed() {
209 undo_strong!();
210 return Err(AcquireError::closed());
211 }
212
213 if !next.acquire_permit(&self.stub) {
214 debug!(" + poll_permit -- no permits");
215
216 debug_assert!(curr.waiter().is_some());
217
218 if maybe_strong.is_none() {
219 if let Some(ref mut permit) = permit {
220 let waiter = permit
222 .waiter
223 .get_or_insert_with(|| Arc::new(WaiterNode::new()));
224
225 waiter.register();
226
227 debug!(" + poll_permit -- to_queued_waiting");
228
229 if !waiter.to_queued_waiting() {
230 debug!(" + poll_permit; waiter already queued");
231 return Ok(NotReady);
234 }
235
236 maybe_strong = Some(WaiterNode::into_non_null(waiter.clone()));
237 } else {
238 return Ok(NotReady);
241 }
242 }
243
244 next.set_waiter(maybe_strong.unwrap());
245 }
246
247 debug!(" + poll_permit -- pre-CAS; next = {:?}", next);
248
249 debug_assert_ne!(curr.0, 0);
250 debug_assert_ne!(next.0, 0);
251
252 match next.compare_exchange(&self.state, curr, AcqRel, Acquire) {
253 Ok(_) => {
254 debug!(" + poll_permit -- CAS ok");
255 match curr.waiter() {
256 Some(prev_waiter) => {
257 let waiter = maybe_strong.unwrap();
258
259 unsafe {
261 prev_waiter.as_ref().next.store(waiter.as_ptr(), Release);
262 }
263
264 debug!(" + poll_permit -- waiter pushed");
265
266 return Ok(NotReady);
267 }
268 None => {
269 debug!(" + poll_permit -- permit acquired");
270
271 undo_strong!();
272
273 return Ok(Ready(()));
274 }
275 }
276 }
277 Err(actual) => {
278 curr = actual;
279 }
280 }
281 }
282 }
283
284 pub fn close(&self) {
287 debug!("+ Semaphore::close");
288
289 let prev = self.rx_lock.fetch_or(1, AcqRel);
291 debug!(" + close -- rx_lock.fetch_add(1)");
292
293 if prev != 0 {
294 debug!("+ close -- locked; prev = {}", prev);
295 return;
298 }
299
300 self.add_permits_locked(0, true);
301 }
302
303 pub fn add_permits(&self, n: usize) {
305 debug!(" + add_permits; n = {}", n);
306
307 if n == 0 {
308 return;
309 }
310
311 let prev = self.rx_lock.fetch_add(n << 1, AcqRel);
314 debug!(" + add_permits; rx_lock.fetch_add(n << 1); n = {}", n);
315
316 if prev != 0 {
317 debug!(" + add_permits -- locked; prev = {}", prev);
318 return;
321 }
322
323 self.add_permits_locked(n, false);
324 }
325
326 fn add_permits_locked(&self, mut rem: usize, mut closed: bool) {
327 while rem > 0 || closed {
328 debug!(
329 " + add_permits_locked -- iter; rem = {}; closed = {:?}",
330 rem, closed
331 );
332
333 if closed {
334 SemState::fetch_set_closed(&self.state, AcqRel);
335 }
336
337 self.add_permits_locked2(rem, closed);
339
340 let n = rem << 1;
341
342 let actual = if closed {
343 let actual = self.rx_lock.fetch_sub(n | 1, AcqRel);
344 debug!(
345 " + add_permits_locked; rx_lock.fetch_sub(n | 1); n = {}; actual={}",
346 n, actual
347 );
348
349 closed = false;
350 actual
351 } else {
352 let actual = self.rx_lock.fetch_sub(n, AcqRel);
353 debug!(
354 " + add_permits_locked; rx_lock.fetch_sub(n); n = {}; actual={}",
355 n, actual
356 );
357
358 closed = actual & 1 == 1;
359 actual
360 };
361
362 rem = (actual >> 1) - rem;
363 }
364
365 debug!(" + add_permits; done");
366 }
367
368 fn add_permits_locked2(&self, mut n: usize, closed: bool) {
373 while n > 0 || closed {
374 let waiter = match self.pop(n, closed) {
375 Some(waiter) => waiter,
376 None => {
377 return;
378 }
379 };
380
381 debug!(" + release_n -- notify");
382
383 if waiter.notify(closed) {
384 n = n.saturating_sub(1);
385 debug!(" + release_n -- dec");
386 }
387 }
388 }
389
390 fn pop(&self, rem: usize, closed: bool) -> Option<Arc<WaiterNode>> {
396 debug!(" + pop; rem = {}", rem);
397
398 'outer: loop {
399 unsafe {
400 let mut head = self.head.with(|head| *head);
401 let mut next_ptr = head.as_ref().next.load(Acquire);
402
403 let stub = self.stub();
404
405 if head == stub {
406 debug!(" + pop; head == stub");
407
408 let next = match NonNull::new(next_ptr) {
409 Some(next) => next,
410 None => {
411 let mut curr = SemState::load(&self.state, Acquire);
429
430 loop {
431 if curr.has_waiter(&self.stub) {
432 debug!(" + pop; inconsistent 1");
434 yield_now();
435 continue 'outer;
436 }
437
438 if rem == 0 {
443 debug_assert!(curr.is_closed(), "state = {:?}", curr);
444 return None;
445 }
446
447 let mut next = curr;
448 next.release_permits(rem, &self.stub);
449
450 match next.compare_exchange(&self.state, curr, AcqRel, Acquire) {
451 Ok(_) => return None,
452 Err(actual) => {
453 curr = actual;
454 }
455 }
456 }
457 }
458 };
459
460 debug!(" + pop; got next waiter");
461
462 self.head.with_mut(|head| *head = next);
463 head = next;
464 next_ptr = next.as_ref().next.load(Acquire);
465 }
466
467 if let Some(next) = NonNull::new(next_ptr) {
468 self.head.with_mut(|head| *head = next);
469
470 return Some(Arc::from_raw(head.as_ptr()));
471 }
472
473 let state = SemState::load(&self.state, Acquire);
474
475 let tail = state.waiter().unwrap();
477
478 if tail != head {
479 debug!(" + pop; inconsistent 2");
481 yield_now();
482 continue 'outer;
483 }
484
485 self.push_stub(closed);
486
487 next_ptr = head.as_ref().next.load(Acquire);
488
489 if let Some(next) = NonNull::new(next_ptr) {
490 self.head.with_mut(|head| *head = next);
491
492 return Some(Arc::from_raw(head.as_ptr()));
493 }
494
495 debug!(" + pop; inconsistent 3");
497 yield_now();
498 }
499 }
500 }
501
502 unsafe fn push_stub(&self, closed: bool) {
503 let stub = self.stub();
504
505 stub.as_ref().next.store(ptr::null_mut(), Relaxed);
509
510 let prev = SemState::new_ptr(stub, closed).swap(&self.state, AcqRel);
514
515 debug_assert_eq!(closed, prev.is_closed());
516
517 let prev = prev.waiter().unwrap();
520
521 debug_assert_ne!(prev, stub);
523
524 prev.as_ref().next.store(stub.as_ptr(), Release);
526 }
527
528 fn stub(&self) -> NonNull<WaiterNode> {
529 unsafe { NonNull::new_unchecked(&*self.stub as *const _ as *mut _) }
530 }
531}
532
533impl fmt::Debug for Semaphore {
534 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
535 fmt.debug_struct("Semaphore")
536 .field("state", &SemState::load(&self.state, Relaxed))
537 .field("head", &self.head.with(|ptr| ptr))
538 .field("rx_lock", &self.rx_lock.load(Relaxed))
539 .field("stub", &self.stub)
540 .finish()
541 }
542}
543
544unsafe impl Send for Semaphore {}
545unsafe impl Sync for Semaphore {}
546
547impl Permit {
550 pub fn new() -> Permit {
563 Permit {
564 waiter: None,
565 state: PermitState::Idle,
566 }
567 }
568
569 pub fn is_acquired(&self) -> bool {
571 self.state == PermitState::Acquired
572 }
573
574 pub fn poll_acquire(&mut self, semaphore: &Semaphore) -> Poll<(), AcquireError> {
577 use futures::Async::*;
578
579 match self.state {
580 PermitState::Idle => {}
581 PermitState::Waiting => {
582 let waiter = self.waiter.as_ref().unwrap();
583
584 if waiter.acquire()? {
585 self.state = PermitState::Acquired;
586 return Ok(Ready(()));
587 } else {
588 return Ok(NotReady);
589 }
590 }
591 PermitState::Acquired => {
592 return Ok(Ready(()));
593 }
594 }
595
596 match semaphore.poll_permit(Some(self))? {
597 Ready(v) => {
598 self.state = PermitState::Acquired;
599 Ok(Ready(v))
600 }
601 NotReady => {
602 self.state = PermitState::Waiting;
603 Ok(NotReady)
604 }
605 }
606 }
607
608 pub fn try_acquire(&mut self, semaphore: &Semaphore) -> Result<(), TryAcquireError> {
610 use futures::Async::*;
611
612 match self.state {
613 PermitState::Idle => {}
614 PermitState::Waiting => {
615 let waiter = self.waiter.as_ref().unwrap();
616
617 if waiter.acquire2().map_err(to_try_acquire)? {
618 self.state = PermitState::Acquired;
619 return Ok(());
620 } else {
621 return Err(TryAcquireError::no_permits());
622 }
623 }
624 PermitState::Acquired => {
625 return Ok(());
626 }
627 }
628
629 match semaphore.poll_permit(None).map_err(to_try_acquire)? {
630 Ready(()) => {
631 self.state = PermitState::Acquired;
632 Ok(())
633 }
634 NotReady => Err(TryAcquireError::no_permits()),
635 }
636 }
637
638 pub fn release(&mut self, semaphore: &Semaphore) {
640 if self.forget2() {
641 semaphore.add_permits(1);
642 }
643 }
644
645 pub fn forget(&mut self) {
653 self.forget2();
654 }
655
656 fn forget2(&mut self) -> bool {
658 match self.state {
659 PermitState::Idle => false,
660 PermitState::Waiting => {
661 let ret = self.waiter.as_ref().unwrap().cancel_interest();
662 self.state = PermitState::Idle;
663 ret
664 }
665 PermitState::Acquired => {
666 self.state = PermitState::Idle;
667 true
668 }
669 }
670 }
671}
672
673impl AcquireError {
676 fn closed() -> AcquireError {
677 AcquireError(())
678 }
679}
680
681fn to_try_acquire(_: AcquireError) -> TryAcquireError {
682 TryAcquireError::closed()
683}
684
685impl fmt::Display for AcquireError {
686 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
687 use std::error::Error;
688 write!(fmt, "{}", self.description())
689 }
690}
691
692impl ::std::error::Error for AcquireError {
693 fn description(&self) -> &str {
694 "semaphore closed"
695 }
696}
697
698impl TryAcquireError {
701 fn closed() -> TryAcquireError {
702 TryAcquireError {
703 kind: ErrorKind::Closed,
704 }
705 }
706
707 fn no_permits() -> TryAcquireError {
708 TryAcquireError {
709 kind: ErrorKind::NoPermits,
710 }
711 }
712
713 pub fn is_closed(&self) -> bool {
715 match self.kind {
716 ErrorKind::Closed => true,
717 _ => false,
718 }
719 }
720
721 pub fn is_no_permits(&self) -> bool {
724 match self.kind {
725 ErrorKind::NoPermits => true,
726 _ => false,
727 }
728 }
729}
730
731impl fmt::Display for TryAcquireError {
732 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
733 use std::error::Error;
734 write!(fmt, "{}", self.description())
735 }
736}
737
738impl ::std::error::Error for TryAcquireError {
739 fn description(&self) -> &str {
740 match self.kind {
741 ErrorKind::Closed => "semaphore closed",
742 ErrorKind::NoPermits => "no permits available",
743 }
744 }
745}
746
747impl WaiterNode {
750 fn new() -> WaiterNode {
751 WaiterNode {
752 state: AtomicUsize::new(NodeState::new().to_usize()),
753 task: AtomicTask::new(),
754 next: AtomicPtr::new(ptr::null_mut()),
755 }
756 }
757
758 fn acquire(&self) -> Result<bool, AcquireError> {
759 if self.acquire2()? {
760 return Ok(true);
761 }
762
763 self.task.register();
764
765 self.acquire2()
766 }
767
768 fn acquire2(&self) -> Result<bool, AcquireError> {
769 use self::NodeState::*;
770
771 match Idle.compare_exchange(&self.state, Assigned, AcqRel, Acquire) {
772 Ok(_) => Ok(true),
773 Err(Closed) => Err(AcquireError::closed()),
774 Err(_) => Ok(false),
775 }
776 }
777
778 fn register(&self) {
779 self.task.register()
780 }
781
782 fn cancel_interest(&self) -> bool {
784 use self::NodeState::*;
785
786 match Queued.compare_exchange(&self.state, QueuedWaiting, AcqRel, Acquire) {
787 Ok(_) => false,
790 Err(Closed) => false,
793 Err(Assigned) => {
796 match self.acquire2() {
797 Ok(true) => true,
798 Ok(false) => panic!(),
800 Err(_) => false,
802 }
803 }
804 Err(state) => panic!("unexpected state = {:?}", state),
805 }
806 }
807
808 fn to_queued_waiting(&self) -> bool {
814 use self::NodeState::*;
815
816 let mut curr = NodeState::load(&self.state, Acquire);
817
818 loop {
819 debug_assert!(curr == Idle || curr == Queued, "actual = {:?}", curr);
820 let next = QueuedWaiting;
821
822 match next.compare_exchange(&self.state, curr, AcqRel, Acquire) {
823 Ok(_) => {
824 if curr.is_queued() {
825 return false;
826 } else {
827 self.next.store(ptr::null_mut(), Relaxed);
829 return true;
830 }
831 }
832 Err(actual) => {
833 curr = actual;
834 }
835 }
836 }
837 }
838
839 fn notify(&self, closed: bool) -> bool {
843 use self::NodeState::*;
844
845 let mut curr = QueuedWaiting;
847
848 loop {
849 let next = match curr {
850 Queued => Idle,
851 QueuedWaiting => {
852 if closed {
853 Closed
854 } else {
855 Assigned
856 }
857 }
858 actual => panic!("actual = {:?}", actual),
859 };
860
861 match next.compare_exchange(&self.state, curr, AcqRel, Acquire) {
862 Ok(_) => match curr {
863 QueuedWaiting => {
864 debug!(" + notify -- task notified");
865 self.task.notify();
866 return true;
867 }
868 other => {
869 debug!(" + notify -- not notified; state = {:?}", other);
870 return false;
871 }
872 },
873 Err(actual) => curr = actual,
874 }
875 }
876 }
877
878 fn revert_to_idle(&self) {
879 use self::NodeState::Idle;
880
881 NodeState::store(&self.state, Idle, Relaxed);
883 }
884
885 fn into_non_null(arc: Arc<WaiterNode>) -> NonNull<WaiterNode> {
886 let ptr = Arc::into_raw(arc);
887 unsafe { NonNull::new_unchecked(ptr as *mut _) }
888 }
889}
890
891const NUM_FLAG: usize = 0b01;
899
900const CLOSED_FLAG: usize = 0b10;
901
902const MAX_PERMITS: usize = usize::MAX >> NUM_SHIFT;
903
904const NUM_SHIFT: usize = 2;
907
908impl SemState {
909 fn new(permits: usize, stub: &WaiterNode) -> SemState {
911 assert!(permits <= MAX_PERMITS);
912
913 if permits > 0 {
914 SemState((permits << NUM_SHIFT) | NUM_FLAG)
915 } else {
916 SemState(stub as *const _ as usize)
917 }
918 }
919
920 fn new_ptr(tail: NonNull<WaiterNode>, closed: bool) -> SemState {
922 let mut val = tail.as_ptr() as usize;
923
924 if closed {
925 val |= CLOSED_FLAG;
926 }
927
928 SemState(val)
929 }
930
931 fn available_permits(&self) -> usize {
933 if !self.has_available_permits() {
934 return 0;
935 }
936
937 self.0 >> NUM_SHIFT
938 }
939
940 fn has_available_permits(&self) -> bool {
942 self.0 & NUM_FLAG == NUM_FLAG
943 }
944
945 fn has_waiter(&self, stub: &WaiterNode) -> bool {
946 !self.has_available_permits() && !self.is_stub(stub)
947 }
948
949 fn acquire_permit(&mut self, stub: &WaiterNode) -> bool {
957 if !self.has_available_permits() {
958 return false;
959 }
960
961 debug_assert!(self.waiter().is_none());
962
963 self.0 -= 1 << NUM_SHIFT;
964
965 if self.0 == NUM_FLAG {
966 self.0 = stub as *const _ as usize;
968 }
969
970 true
971 }
972
973 fn release_permits(&mut self, permits: usize, stub: &WaiterNode) {
977 debug_assert!(permits > 0);
978
979 if self.is_stub(stub) {
980 self.0 = (permits << NUM_SHIFT) | NUM_FLAG | (self.0 & CLOSED_FLAG);
981 return;
982 }
983
984 debug_assert!(self.has_available_permits());
985
986 self.0 += permits << NUM_SHIFT;
987 }
988
989 fn is_waiter(&self) -> bool {
990 self.0 & NUM_FLAG == 0
991 }
992
993 fn waiter(&self) -> Option<NonNull<WaiterNode>> {
995 if self.is_waiter() {
996 let waiter = NonNull::new(self.as_ptr()).expect("null pointer stored");
997
998 Some(waiter)
999 } else {
1000 None
1001 }
1002 }
1003
1004 fn as_ptr(&self) -> *mut WaiterNode {
1006 (self.0 & !CLOSED_FLAG) as *mut WaiterNode
1007 }
1008
1009 fn set_waiter(&mut self, waiter: NonNull<WaiterNode>) {
1013 let waiter = waiter.as_ptr() as usize;
1014 debug_assert!(waiter & NUM_FLAG == 0);
1015 debug_assert!(!self.is_closed());
1016
1017 self.0 = waiter;
1018 }
1019
1020 fn is_stub(&self, stub: &WaiterNode) -> bool {
1021 self.as_ptr() as usize == stub as *const _ as usize
1022 }
1023
1024 fn load(cell: &AtomicUsize, ordering: Ordering) -> SemState {
1026 let value = cell.load(ordering);
1027 debug!(" + SemState::load; value = {}", value);
1028 SemState(value)
1029 }
1030
1031 fn swap(&self, cell: &AtomicUsize, ordering: Ordering) -> SemState {
1033 let prev = SemState(cell.swap(self.to_usize(), ordering));
1034 debug_assert_eq!(prev.is_closed(), self.is_closed());
1035 prev
1036 }
1037
1038 fn compare_exchange(
1040 &self,
1041 cell: &AtomicUsize,
1042 prev: SemState,
1043 success: Ordering,
1044 failure: Ordering,
1045 ) -> Result<SemState, SemState> {
1046 debug_assert_eq!(prev.is_closed(), self.is_closed());
1047
1048 let res = cell.compare_exchange(prev.to_usize(), self.to_usize(), success, failure);
1049
1050 debug!(
1051 " + SemState::compare_exchange; prev = {}; next = {}; result = {:?}",
1052 prev.to_usize(),
1053 self.to_usize(),
1054 res
1055 );
1056
1057 res.map(SemState).map_err(SemState)
1058 }
1059
1060 fn fetch_set_closed(cell: &AtomicUsize, ordering: Ordering) -> SemState {
1061 let value = cell.fetch_or(CLOSED_FLAG, ordering);
1062 SemState(value)
1063 }
1064
1065 fn is_closed(&self) -> bool {
1066 self.0 & CLOSED_FLAG == CLOSED_FLAG
1067 }
1068
1069 fn to_usize(&self) -> usize {
1071 self.0
1072 }
1073}
1074
1075impl fmt::Debug for SemState {
1076 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1077 let mut fmt = fmt.debug_struct("SemState");
1078
1079 if self.is_waiter() {
1080 fmt.field("state", &"<waiter>");
1081 } else {
1082 fmt.field("permits", &self.available_permits());
1083 }
1084
1085 fmt.finish()
1086 }
1087}
1088
1089impl NodeState {
1092 fn new() -> NodeState {
1093 NodeState::Idle
1094 }
1095
1096 fn from_usize(value: usize) -> NodeState {
1097 use self::NodeState::*;
1098
1099 match value {
1100 0 => Idle,
1101 1 => Queued,
1102 2 => QueuedWaiting,
1103 3 => Assigned,
1104 4 => Closed,
1105 _ => panic!(),
1106 }
1107 }
1108
1109 fn load(cell: &AtomicUsize, ordering: Ordering) -> NodeState {
1110 NodeState::from_usize(cell.load(ordering))
1111 }
1112
1113 fn store(cell: &AtomicUsize, value: NodeState, ordering: Ordering) {
1115 cell.store(value.to_usize(), ordering);
1116 }
1117
1118 fn compare_exchange(
1119 &self,
1120 cell: &AtomicUsize,
1121 prev: NodeState,
1122 success: Ordering,
1123 failure: Ordering,
1124 ) -> Result<NodeState, NodeState> {
1125 cell.compare_exchange(prev.to_usize(), self.to_usize(), success, failure)
1126 .map(NodeState::from_usize)
1127 .map_err(NodeState::from_usize)
1128 }
1129
1130 fn is_queued(&self) -> bool {
1132 use self::NodeState::*;
1133
1134 match *self {
1135 Queued | QueuedWaiting => true,
1136 _ => false,
1137 }
1138 }
1139
1140 fn to_usize(&self) -> usize {
1141 *self as usize
1142 }
1143}