Merge pull request #194 from bgamari/concurrency

Concurrency  primitives

Author: bgamari

src/zinc/hal/cortex_common/irq.rs

@@ -0,0 +1,77 @@
+// Zinc, the bare metal stack for rust.
+// Copyright 2014 Ben Gamari <[email protected]>
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Disabling and enabling interrupts
+
+use core::ops::Drop;
+use core::intrinsics::abort;
+
+/// Phantom type to indicate that interrupts are disabled.
+pub struct NoInterrupts {
+  #[allow(dead_code)]
+  contents: ()
+}
+
+impl NoInterrupts {
+  /// Start a new critical section
+  pub fn new() -> NoInterrupts {
+    unsafe {
+      disable_irqs();
+    }
+    NoInterrupts { contents: () }
+  }
+}
+
+impl Drop for NoInterrupts {
+  fn drop(&mut self) {
+    unsafe {
+      enable_irqs();
+    }
+  }
+}
+
+static mut irq_level : uint = 0;
+
+/// Disables all interrupts except Reset, HardFault, and NMI.
+/// Note that this is reference counted: if `disable_irqs` is called
+/// twice then interrupts will only be re-enabled upon the second call
+/// to `enable_irqs`.
+#[cfg(not(test))]
+#[inline(always)]
+unsafe fn disable_irqs() {
+  asm!("cpsid i" :::: "volatile");
+  irq_level += 1;
+}
+
+#[cfg(test)]
+unsafe fn disable_irqs() { unimplemented!() }
+
+/// Enables all interrupts except Reset, HardFault, and NMI.
+#[cfg(not(test))]
+#[inline(always)]
+unsafe fn enable_irqs() {
+  if irq_level == 0 {
+    abort();
+  }
+  // There is no race condition here as we know that interrupts are
+  // disabled.
+  irq_level -= 1;
+  if irq_level == 0 {
+    asm!("cpsie i" :::: "volatile");
+  }
+}
+
+#[cfg(test)]
+unsafe fn enable_irqs() { unimplemented!() }

src/zinc/hal/cortex_common/mod.rs

@@ -21,3 +21,4 @@ pub mod systick;
 pub mod mpu;
 pub mod nvic;
 pub mod scb;
+pub mod irq;

src/zinc/hal/cortex_m0/mod.rs

@@ -23,4 +23,5 @@ crate. `isr.rs` provides ISR vector table.
 pub use super::cortex_common::systick;
 pub use super::cortex_common::scb;
 pub use super::cortex_common::nvic;
+pub use super::cortex_common::irq;
 pub mod lock;

src/zinc/hal/cortex_m3/mod.rs

@@ -24,5 +24,6 @@ pub use super::cortex_common::systick;
 pub use super::cortex_common::scb;
 pub use super::cortex_common::nvic;
 pub use super::cortex_common::mpu;
+pub use super::cortex_common::irq;
 #[cfg(cfg_multitasking)] pub mod sched;
 #[cfg(cfg_multitasking)] pub mod lock;

src/zinc/hal/cortex_m3/sched.rs

@@ -100,58 +100,3 @@ unsafe fn task_finished() {
 #[cfg(test)]
 unsafe fn task_finished() { unimplemented!() }
 
-/// Phantom type to indicate that interrupts are disabled.
-pub struct NoInterrupts {
-  contents: ()
-}
-
-impl NoInterrupts {
-  pub fn new() -> NoInterrupts {
-    unsafe {
-      disable_irqs();
-    }
-    NoInterrupts { contents: () }
-  }
-}
-
-impl Drop for NoInterrupts {
-  fn drop(&mut self) {
-    unsafe {
-      enable_irqs();
-    }
-  }
-}
-
-static mut irq_level : uint = 0;
-
-/// Disables all interrupts except Reset, HardFault, and NMI.
-/// Note that this is reference counted: if `disable_irqs` is called
-/// twice then interrupts will only be re-enabled upon the second call
-/// to `enable_irqs`.
-#[cfg(not(test))]
-#[inline(always)]
-unsafe fn disable_irqs() {
-  if irq_level == 0 {
-    asm!("cpsid i" :::: "volatile");
-  }
-  irq_level += 1;
-}
-
-#[cfg(test)]
-unsafe fn disable_irqs() { unimplemented!() }
-
-/// Enables all interrupts except Reset, HardFault, and NMI.
-#[cfg(not(test))]
-#[inline(always)]
-unsafe fn enable_irqs() {
-  if irq_level == 0 {
-    abort();
-  }
-  irq_level -= 1;
-  if irq_level == 0 {
-    asm!("cpsie i" :::: "volatile");
-  }
-}
-
-#[cfg(test)]
-unsafe fn enable_irqs() { unimplemented!() }

src/zinc/hal/cortex_m4/mod.rs

@@ -24,3 +24,4 @@ pub use super::cortex_common::systick;
 pub use super::cortex_common::scb;
 pub use super::cortex_common::nvic;
 pub use super::cortex_common::mpu;
+pub use super::cortex_common::irq;

src/zinc/os/cond_var.rs

@@ -13,69 +13,131 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use core::option::{None, Some};
-use core::ty::Unsafe;
-use core::kinds::marker;
-use core::kinds::Share;
+//! Condition variables
 
-use hal::cortex_m3::sched::NoInterrupts;
-use util::queue::{Queue, Node};
-use os::task::{TaskDescriptor, Tasks};
+pub use os::cond_var::internal::{CondVar, COND_VAR_INIT};
 
-pub struct CondVar {
-  waiting: Queue<*mut TaskDescriptor>
-}
+#[cfg(multitasking)]
+mod internal {
+  use core::option::{None, Some};
+  use core::ty::Unsafe;
+  use core::kinds::marker;
+  use core::kinds::Share;
 
-pub static COND_VAR_INIT: CondVar = CondVar {
-  waiting: Queue {
-    head: Unsafe { value: 0 as *mut Node<*mut TaskDescriptor>, marker1: marker::InvariantType },
-    tail: Unsafe { value: 0 as *mut Node<*mut TaskDescriptor>, marker1: marker::InvariantType },
-  }
-};
+  use hal::cortex_m3::sched::NoInterrupts;
+  use util::queue::{Queue, Node};
+  use os::task::{TaskDescriptor, Tasks};
 
-impl CondVar {
-  pub fn new() -> CondVar {
-    CondVar { waiting: Queue::new() }
+  /// A condition variable
+  pub struct CondVar {
+    waiting: Queue<*mut TaskDescriptor>
   }
 
-  /// Wait on a condition variable.
-  pub fn wait<'a>(&'a self) {
-    /*
-     * The signalling thread is responsible for removing the waiting
-     * thread which ensures that a signal wakes up exactly one thread
-     * whenever there is one waiting.
-     */
-    unsafe {
-      let crit = NoInterrupts::new();
-      let mut waiting = Node::new(Tasks.current_task() as *mut TaskDescriptor);
-      self.waiting.push(&mut waiting, &crit);
-      Tasks.current_task().block(crit);
+  /// Static initializer
+  pub const COND_VAR_INIT: CondVar = CondVar {
+    waiting: Queue {
+      head: Unsafe { value: 0 as *mut Node<*mut TaskDescriptor>, marker1: marker::InvariantType },
+      tail: Unsafe { value: 0 as *mut Node<*mut TaskDescriptor>, marker1: marker::InvariantType },
+    }
+  };
+
+  impl CondVar {
+    /// Create a new condition variable
+    pub fn new() -> CondVar {
+      CondVar { waiting: Queue::new() }
     }
-  }
 
-  /// Wake up a thread waiting on a condition variable.
-  pub fn signal<'a>(&'a self) {
-    unsafe {
-      let crit = NoInterrupts::new();
-      match self.waiting.pop(&crit) {
-        None => { },
-        Some(task) => (*(*task).data).unblock(&crit)
+    /// Wait on a condition variable.
+    pub fn wait(&self) {
+      /*
+       * The signalling thread is responsible for removing the waiting
+       * thread which ensures that a signal wakes up exactly one thread
+       * whenever there is one waiting.
+       */
+      unsafe {
+        let crit = NoInterrupts::new();
+        let mut waiting = Node::new(Tasks.current_task() as *mut TaskDescriptor);
+        self.waiting.push(&mut waiting, &crit);
+        Tasks.current_task().block(crit);
       }
     }
-  }
 
-  /// Wake up all threads waiting on a condition variable.
-  pub fn broadcast<'a>(&'a self) {
-    unsafe {
-      let crit = NoInterrupts::new();
-      loop {
+    /// Wake up a thread waiting on a condition variable.
+    pub fn signal(&self) {
+      unsafe {
+        let crit = NoInterrupts::new();
         match self.waiting.pop(&crit) {
-          None => break,
+          None => { },
           Some(task) => (*(*task).data).unblock(&crit)
         }
       }
     }
+
+    /// Wake up all threads waiting on a condition variable.
+    pub fn broadcast(&self) {
+      unsafe {
+        let crit = NoInterrupts::new();
+        loop {
+          match self.waiting.pop(&crit) {
+            None => break,
+            Some(task) => (*(*task).data).unblock(&crit)
+          }
+        }
+      }
+    }
   }
+
+  impl Share for CondVar {}
 }
 
-impl Share for CondVar {}
+#[cfg(not(multitasking))]
+mod internal {
+  use core::kinds::marker;
+  use core::kinds::Share;
+  use core::cell::UnsafeCell;
+
+  /// A condition variable
+  pub struct CondVar {
+    waiting: UnsafeCell<bool>,
+    nocopy: marker::NoCopy
+  }
+
+  /// Static initializer
+  pub const COND_VAR_INIT: CondVar = CondVar {
+    waiting: UnsafeCell { value: false },
+    nocopy: marker::NoCopy,
+  };
+
+  impl CondVar {
+    /// Create a new condition variable
+    pub fn new() -> CondVar {
+      CondVar {
+        waiting: UnsafeCell::new(false),
+        nocopy: marker::NoCopy,
+      }
+    }
+
+    /// Wait on a condition variable.
+    pub fn wait(&self) {
+      unsafe {
+        while *self.waiting.get() {
+          asm!("wfi")
+        }
+      }
+    }
+
+    /// Wake up a thread waiting on a condition variable.
+    pub fn signal(&self) {
+      unsafe {
+        *self.waiting.get() = true;
+      }
+    }
+
+    /// Wake up all threads waiting on a condition variable.
+    pub fn broadcast(&self) {
+      self.signal();
+    }
+  }
+
+  impl Share for CondVar {}
+}

src/zinc/os/mod.rs

@@ -23,5 +23,5 @@ incompatible direct hal usage in some cases.
 // pub mod debug;
 pub mod syscall;
 #[cfg(cfg_multitasking)] pub mod task;
-#[cfg(cfg_multitasking)] pub mod mutex;
-#[cfg(cfg_multitasking)] pub mod cond_var;
+pub mod mutex;
+pub mod cond_var;