Changeset 20815

Timestamp:

09/16/07 19:55:49 (1 year ago)

Author:

patrick

Message:

Added a Linux-specific implementation of vpr::ThreadPosix::[gs]etRunOn().
Added vpr::ThreadWin?32::[gs]etRunOn() and vpr::ThreadNSPR::[gs]etRunOn().
The NSPR implementation currently does nothing. Changed the signatuer of
vpr::Thread::getRunOn() to return std::vector<unsigned int>. While
vpr::Thread::setRunOn() only allows choosing a single processor, threads are
allowed to run on multiple processors by default. In this way, we can
retrieve that information if necessary.

Bumped the version to 2.1.6.

Files:

• juggler/trunk/modules/vapor/ChangeLog (modified) (1 diff)
• juggler/trunk/modules/vapor/VERSION (modified) (1 diff)
• juggler/trunk/modules/vapor/vpr/md/NSPR/Thread/ThreadNSPR.h (modified) (1 diff)
• juggler/trunk/modules/vapor/vpr/md/POSIX/Thread/ThreadPosix.cpp (modified) (2 diffs)
• juggler/trunk/modules/vapor/vpr/md/POSIX/Thread/ThreadPosix.h (modified) (3 diffs)
• juggler/trunk/modules/vapor/vpr/md/WIN32/Thread/ThreadWin32.cpp (modified) (1 diff)
• juggler/trunk/modules/vapor/vpr/md/WIN32/Thread/ThreadWin32.h (modified) (2 diffs)

juggler/trunk/modules/vapor/ChangeLog

@@ -1 +1 @@
-DATE       AUTHOR   CHANGE
----------- -------- -----------------------------------------------------------
+2007-09-16 patrick  Added vpr::ThreadWin32::setRunOn() and
+                    vpr::ThreadWin32::getRunOn(). Added Linux-specific
+                    implementations of vpr::ThreadPosix::setRunOn() and
+                    vpr::ThreadPosix::getRunOn(). Changed
+                    vpr::Thread::getRunOn() so that it now returns
+                    std::vector<unsigned int>.
+                    NEW VERSION: 2.1.6
-2007-09-06 patrick  Implemented stack trace printing on Mac OS X.
-2007-09-04 patrick  Set VPR_BASE_DIR automatically on all platforms.

juggler/trunk/modules/vapor/VERSION

@@ +1 @@
+2.1.6-0 @09/16/2007 00:55:00 UTC@
-2.1.5-0 @08/22/2007 00:45:00 UTC@
-2.1.4-0 @07/08/2007 21:15:00 UTC@

juggler/trunk/modules/vapor/vpr/md/NSPR/Thread/ThreadNSPR.h

@@ -245 +245 @@
-   virtual void setPrio(const VPRThreadPriority prio);
-
+   virtual void setRunOn(const unsigned int)
+   {
+      /* Do nothing. */ ;
+   }
+
+   virtual std::vector<unsigned int> getRunOn()
+   {
+      return std::vector<unsigned int>();
+   }
+
-   /**
-    * Sends the specified signal to this thread (not necessarily \c SIGKILL).

juggler/trunk/modules/vapor/vpr/md/POSIX/Thread/ThreadPosix.cpp

@@ -58 +58 @@
-// include vpr/Thread/Thread.h or ThreadPosix.h.
-#include <vpr/Util/Debug.h>
+#include <vpr/Util/Error.h>
-#include <vpr/Util/IllegalArgumentException.h>
-#include <vpr/Util/ResourceException.h>
@@ -382 +383 @@
-}
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-   }
-   else
-   {
-      throw vpr::IllegalArgumentException(
-
+
+
-      );
-   }
+}
+
+std::vector<unsigned int> ThreadPosix::getRunOn()
+{
+   std::vector<unsigned int> cpus;
+
+   if ( ThreadPosix::self() == this )
+   {
+#if defined(VPR_OS_IRIX)
+      if ( mScope == VPR_GLOBAL_THREAD )
+      {
+         int cpu;
+         if ( pthread_getrunon_np(&cpu) == 0 )
+         {
+            cpus.push_back(cpu);
+         }
+         else
+         {
+            std::ostringstream msg_stream;
+            msg_stream << "Failed to query CPU affinity: "
+                       << Error::getCurrentErrorMsg();
+            throw vpr::Exception(msg_stream.str(), VPR_LOCATION);
+         }
+      }
+      else
+      {
+         throw vpr::IllegalArgumentException(
+            "This thread is not a system-scope thread", VPR_LOCATION
+         );
+      }
+#elif defined(VPR_OS_Linux)
+      cpu_set_t cpu_mask;
+      CPU_ZERO(&cpu_mask);
+      const int result = sched_getaffinity(0, sizeof(cpu_mask), &cpu_mask);
+
+      if ( result == 0 )
+      {
+         const long cpu_count(sysconf(_SC_NPROCESSORS_CONF));
+         cpus.reserve(cpu_count);
+
+         for ( int i = 0; i < cpu_count; ++i )
+         {
+            if ( CPU_ISSET(i, &cpu_mask) )
+            {
+               cpus.push_back(cpu);
+            }
+         }
+      }
+      else
+      {
+         std::ostringstream msg_stream;
+         msg_stream << "Failed to query CPU affinity: "
+                    << Error::getCurrentErrorMsg();
+         throw vpr::Exception(msg_stream.str(), VPR_LOCATION);
+      }
-#else
-boost::ignore_unused_variable_warning(cpu);
-std::cerr << "vpr::ThreadPosix::setRunOn(): Not available on this
+   std::cerr << "vpr::ThreadPosix::getRunOn(): Not available on this "
+             << "operating
-#endif
-}
-
-int ThreadPosix::getRunOn()
-{
-#ifdef VPR_OS_IRIX
-   int cur_cpu;
-
-   if ( mScope == VPR_GLOBAL_THREAD )
-   {
-      pthread_getrunon_np(&cur_cpu);
-   }
-   else
-   {
-      throw vpr::IllegalArgumentException(
-
+
+
-      );
-   }
-
-
-
-
-
-
+
-}
-

juggler/trunk/modules/vapor/vpr/md/POSIX/Thread/ThreadPosix.h

@@ -46 +46 @@
-
-#include <stdlib.h>
+#include <vector>
-#include <pthread.h>
-#include <sys/types.h>
@@ -307 +308 @@
-    * will exclusively run).
-    *
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-   /**
@@ -324 +335 @@
-    *
-    * @pre The thread must have been set to be a system-scope thread, and
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-   /**

juggler/trunk/modules/vapor/vpr/md/WIN32/Thread/ThreadWin32.cpp

@@ -304 +304 @@
-      throw vpr::IllegalArgumentException(msg_stream.str(), VPR_LOCATION);
-   }
+}
+
+void ThreadWin32::setRunOn(const unsigned int cpu)
+{
+   // Even though we have easy access to mThreadHandle, we perform this test
+   // to ensure semantic compatibility with vpr::ThreadPosix.
+   if ( ThreadWin32::self() == this )
+   {
+      // The value of cpu is zero-based, but the CPU identifier values from
+      // Windows are one-based.
+      DWORD_PTR result = SetThreadAffinityMask(mThreadHandle, 0x1 << cpu);
+
+      if ( result == 0 )
+      {
+         std::ostringstream msg_stream;
+         msg_stream << "Failed to set CPU affinity: "
+                    << vpr::Error::getCurrentErrorMsg();
+         throw vpr::Exception(msg_stream.str(), VPR_LOCATION);
+      }
+   }
+   else
+   {
+      throw vpr::IllegalArgumentException(
+         "CPU affinity can only be set for a thread object from its thread",
+         VPR_LOCATION
+      );
+   }
+}
+
+std::vector<unsigned int> ThreadWin32::getRunOn()
+{
+   std::vector<unsigned int> cpus;
+
+   if ( ThreadPosix::self() == this )
+   {
+      DWORD_PTR proc_affinity_mask;
+      DWORD_PTR sys_affinity_mask;
+
+      const BOOL result = GetProcessAffinityMask(mThreadHandle,
+                                                 &proc_affinity_mask,
+                                                 &sys_affinity_mask);
+
+      if ( result )
+      {
+         const size_t cpu_count(sizeof(DWORD_PTR) * 8);
+         cpus.reserve(cpu_count);
+
+         // Find the first CPU in proc_affinity_mask on which this thread is
+         // allowed to run.
+         for ( int i = 0; i < cpu_count; ++i )
+         {
+            if ( (0x1 << i) & proc_affinity_mask )
+            {
+               cpus.push_back(i);
+            }
+         }
+      }
+      else
+      {
+      }
+   }
+   else
+   {
+      throw vpr::IllegalArgumentException(
+         "CPU affinity can only be queired for a thread object from its thread",
+         VPR_LOCATION
+      );
+   }
+
+   return cpus;
-}
-

juggler/trunk/modules/vapor/vpr/md/WIN32/Thread/ThreadWin32.h

@@ -46 +46 @@
-
-#include <process.h>
+#include <vector>
-
-// To get the Win32 key stuff for storing self.
@@ -262 +263 @@
-
-   /**
+    * Sets the CPU affinity for this thread (the CPU on which this thread
+    * will exclusively run).
+    *
+    * @pre The thread from which this method was invoked must be the same as
+    *      the thread spawned by this object.
+    * @post The CPU affinity is set or an exception is thrown.
+    *
+    * @param cpu The CPU on which this thread will run exclusively. This value
+    *            is zero-based and therefore must be less than the number of
+    *            processors available on the computer.
+    *
+    * @throw vpr::IllegalArgumentException
+    *           Thrown if the thread spawned through the use of this object is
+    *           not the thread from which this method was invoked.
+    * @throw vpr::Exception
+    *           Thrown if the CPU affinity for the running thread could not
+    *           be changed.
+    */
+   void setRunOn(const unsigned int cpu);
+
+   /**
+    * Gets the CPU affinity for this thread (the CPU on which this thread
+    * exclusively runs).
+    *
+    * @pre The thread must have been set to be a system-scope thread, and
+    *      a previous affinity must have been set using setRunOn(). The thread
+    *      from which this method was invoked must be the same as the thread
+    *      spawned by this object.
+    * @post The CPU affinity for this thread is returned to the caller.
+    *
+    * @return The CPU affinity for this thread (possibly set by a previous
+    *         call to setRunOn()).
+    *
+    * @throw vpr::IllegalArgumentException
+    *           Thrown if the thread spawned through the use of this object is
+    *           not the thread from which this method was invoked.
+    * @throw vpr::Exception
+    *           Thrown if the CPU affinity for the running thread could not
+    *           be queried.
+    */
+   std::vector<unsigned int> getRunOn();
+
+   /**
-    * Yields execution of the calling thread to allow a different blocked
-    * thread to execute.