Changeset 509

Timestamp:

07/12/06 19:22:10 (6 years ago)

Author:

sean

Message:

Buulk check-in of fixes. Added documentation, restructuring code where necessary to appease DDoc, and made some resource management changes to Thread.

Files:

• trunk/src/ares/std/array.d (modified) (9 diffs)
• trunk/src/ares/std/atomic.d (modified) (10 diffs)
• trunk/src/ares/std/exception.d (modified) (3 diffs)
• trunk/src/ares/std/thread.d (modified) (17 diffs)
• trunk/src/ares/std/traits.d (modified) (2 diffs)
• trunk/src/ares/std/unicode.d (modified) (4 diffs)
• trunk/src/ares/std/vararg.d (modified) (4 diffs)

trunk/src/ares/std/array.d

@@ -45 +45 @@
-
-
-/**
- * Temporary until a predicate module can be created.
- */
-template equalTo( Elem )
-{
-    /**
-
+ Temporary until a predicate module can be created.
-     */
-    bool equalTo( Elem a, Elem  b )
@@ -60 +57 @@
-
-
-/**
- *
- */
- /+
-template find( Elem )
@@ -76 +70 @@
-
-
-/**
- *
- */
- template find( Elem, Pred )
-{
@@ -109 +100 @@
-
-
-/**
- *
- */
-template find( Elem )
-{
@@ -125 +113 @@
-
-
-/**
- *
- */
-template find( Elem, Pred )
-{
@@ -248 +233 @@
-
-
-/**
- *
- */
- /+
-template rfind( Elem )
@@ -264 +246 @@
-
-
-/**
- *
- */
-template rfind( Elem, Pred )
-{
@@ -302 +281 @@
-
-
-/**
- *
- */
-template rfind( Elem )
-{
@@ -318 +294 @@
-
-
-/**
- *
- */
-template rfind( Elem, Pred )
-{

trunk/src/ares/std/atomic.d

@@ -76 +76 @@
-private
-{
+  version( DDoc ) {} else
+  {
-    import std.traits;
-
@@ -111 +113 @@
-    }
-}
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// DDoc Documentation for Atomic Functions
+////////////////////////////////////////////////////////////////////////////////
+
+
+version( DDoc )
+{
+    ////////////////////////////////////////////////////////////////////////////
+    // Atomic Load
+    ////////////////////////////////////////////////////////////////////////////
+
+
+    /**
+     * Supported msync values:
+     *  msync.none
+     *  msync.hlb
+     *  msync.ddhlb
+     *  msync.acq
+     */
+    template atomicLoad( msync ms, T )
+    {
+        /**
+         * Refreshes the contents of 'val' from main memory.  This operation is
+         * both lock-free and atomic.
+         *
+         * Returns:
+         *  The loaded value.
+         *
+         * Params:
+         *  val = The value to load.  This value must be properly aligned.
+         */
+        T atomicLoad( inout T val )
+        {
+            return val;
+        }
+    }
+
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Atomic Store
+    ////////////////////////////////////////////////////////////////////////////
+
+
+    /**
+     * Supported msync values:
+     *  msync.none
+     *  msync.ssb
+     *  msync.acq
+     *  msync.rel
+     */
+    template atomicStore( msync ms, T )
+    {
+        /**
+         * Stores 'newval' to the memory referenced by 'val'.  This operation
+         * is both lock-free and atomic.
+         *
+         * Params:
+         *  val     = The destination variable.
+         *  newval  = The value to store.
+         */
+        void atomicStore( inout T val, T newval )
+        {
+
+        }
+    }
+
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Atomic StoreIf
+    ////////////////////////////////////////////////////////////////////////////
+
+
+    /**
+     * Supported msync values:
+     *  msync.none
+     *  msync.ssb
+     *  msync.acq
+     *  msync.rel
+     */
+    template atomicStoreIf( msync ms, T )
+    {
+        /**
+         * Stores 'newval' to the memory referenced by 'val' if val is equal to
+         * 'equalTo'.  This operation is both lock-free and atomic.
+         *
+         * Returns:
+         *  true if the store occurred, false if not.
+         *
+         * Params:
+         *  val     = The destination variable.
+         *  newval  = The value to store.
+         *  equalTo = The comparison value.
+         */
+        bool atomicStoreIf( inout T val, T newval, T equalTo )
+        {
+            return false;
+        }
+    }
+
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Atomic Increment
+    ////////////////////////////////////////////////////////////////////////////
+
+
+    /**
+     * Supported msync values:
+     *  msync.none
+     *  msync.ssb
+     *  msync.acq
+     *  msync.rel
+     */
+    template atomicIncrement( msync ms, T )
+    {
+        /**
+         * This operation is only legal for built-in value and pointer types,
+         * and is equivalent to an atomic "val = val + 1" operation.  This
+         * function exists to facilitate use of the optimized increment
+         * instructions provided by some architecures.  If no such instruction
+         * exists on the target platform then the behavior will perform the
+         * operation using more traditional means.  This operation is both
+         * lock-free and atomic.
+         *
+         * Returns:
+         *  The result of an atomicLoad of val immediately following the
+         *  increment operation.  This value is not required to be equal to the
+         *  newly stored value.  Thus, competing writes are allowed to occur
+         *  between the increment and successive load operation.
+         *
+         * Params:
+         *  val = The value to increment.
+         */
+        T atomicIncrement( inout T val )
+        {
+            return val;
+        }
+    }
+
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Atomic Decrement
+    ////////////////////////////////////////////////////////////////////////////
+
+
+    /**
+     * Supported msync values:
+     *  msync.none
+     *  msync.ssb
+     *  msync.acq
+     *  msync.rel
+     */
+    template atomicDecrement( msync ms, T )
+    {
+        /**
+         * This operation is only legal for built-in value and pointer types,
+         * and is equivalent to an atomic "val = val - 1" operation.  This
+         * function exists to facilitate use of the optimized decrement
+         * instructions provided by some architecures.  If no such instruction
+         * exists on the target platform then the behavior will perform the
+         * operation using more traditional means.  This operation is both
+         * lock-free and atomic.
+         *
+         * Returns:
+         *  The result of an atomicLoad of val immediately following the
+         *  increment operation.  This value is not required to be equal to the
+         *  newly stored value.  Thus, competing writes are allowed to occur
+         *  between the increment and successive load operation.
+         *
+         * Params:
+         *  val = The value to decrement.
+         */
+        T atomicDecrement( inout T val )
+        {
+            return val;
+        }
+    }
+}
-
-
@@ -118 +300 @@
-
-
-
+
-{
-version( X86 )
+private
-    {
-        ////////////////////////////////////////////////////////////////////////
@@ -127 +309 @@
-
-
-        //
-        // NOTE: Strictly speaking, the x86 supports atomic operations on
-        //       unaligned values.  However, this is far slower than the
-        //       common case, so such behavior should be prohibited.
-        //
-        template atomicValueIsProperlyAligned( T )
-        {
@@ -1094 +1274 @@
-        }
-    }
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-    //
-    // NOTE: x86 loads implicitly have acquire semantics so a membar is only necessary on release
-    //
-
-    /**
-     * Refreshes the contents of 'val' from main memory.  This operation is both lock-free and atomic.
-     *
-     * Returns:
-     *  The loaded value.
-     *
-     * Params:
-     *  val = The value to load.  This value must be properly aligned.
-     */
-    template atomicLoad( msync ms : msync.none, T )  { alias doAtomicLoad!(isSinkOp!(ms),T) atomicLoad; }
- /// ditto
- /// ditto
- /// ditto
+
+
+
-
-    //
@@ -1126 +1293 @@
-    //
-
-    /**
-     * Stores 'newval' to the memory referenced by 'val'.  This operation is both lock-free and atomic.
-     *
-     * Params:
-     *  val     = The destination variable.
-     *  newval  = The value to store.
-     */
-    template atomicStore( msync ms : msync.none, T ) { alias doAtomicStore!(isHoistOp!(ms),T) atomicStore; }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-    template atomicStoreIf( msync ms : msync.none, T ) { alias doAtomicStoreIf!(ms!=msync.none,T) atomicStoreIf; }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-    template atomicIncrement( msync ms : msync.none, T ) { alias doAtomicIncrement!(ms!=msync.none,T) atomicIncrement; }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-    template atomicDecrement( msync ms : msync.none, T ) { alias doAtomicDecrement!(ms!=msync.none,T) atomicDecrement; }
- /// ditto
- /// ditto
- /// ditto
+
+
+
-}
-
@@ -1203 +1321 @@
-
-/**
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
- */
-struct Atomic( T )
-{
+    ////////////////////////////////////////////////////////////////////////////
+    // Atomic Load
+    ////////////////////////////////////////////////////////////////////////////
+
+
+    template load( msync ms )
+    {
+        static assert( ms == msync.none  || ms == msync.hlb ||
+                       ms == msync.ddhlb || ms == msync.acq,
+                       "ms must be one of: msync.none, msync.hlb, msync.ddhlb, msync.acq" );
+
-    /**
-
+
+
-     *
-     * Returns:
-     *  The loaded value.
-     */
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    /**
-
+
+
-     *
-     * Params:
-     *  newval  = The value to store.
-     */
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    /**
-* Stores 'newval' to the memory referenced by this value if val is equal to 'equalTo'.  This operation
-*
+    * Stores 'newval' to the memory referenced by this value if val is
+    * equal to 'equalTo'.  This operation
-     *
-     * Returns:
@@ -1246 +1405 @@
-     *  equalTo = The comparison value.
-     */
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    static if( isValidNumericType!(T) )
-    {
+        ////////////////////////////////////////////////////////////////////////
+        // Atomic Increment
+        ////////////////////////////////////////////////////////////////////////
+
+
+        template increment( msync ms )
+        {
+            static assert( ms == msync.none || ms == msync.ssb ||
+                           ms == msync.acq  || ms == msync.rel,
+                           "ms must be one of: msync.none, msync.ssb, msync.acq, msync.rel" );
+
-        /**
-
-
-
-
-
+
+
+
+
+
+
+
-         *
-         * Returns:
-
-
+
+
+
-         *  occur between the increment and successive load operation.
-         */
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-        /**
-
-
-
-
-
+
+
+
+
+
+
+
-         *
-         * Returns:
-
-
+
+
+
-         *  occur between the increment and successive load operation.
-         */
-
-
-
-
+
+
+
+
+
-    }
-
@@ -1300 +1500 @@
-private
-{
+  version( DDoc ) {} else
+  {
-    template testLoad( msync ms, T )
-    {
@@ -1405 +1607 @@
-        }
-    }
+  }
-}
-

trunk/src/ares/std/exception.d

@@ -199 +199 @@
- *  file = The name of the file that signaled this error.
- *  line = The line number on which this error occurred.
- *  msg  = An error message supplied by the user.
- */
-extern (C) void onAssertError( char[] file, uint line )
-{
-!assertHandler
+assertHandler is null
-        throw new AssertException( file, line );
-    assertHandler( file, line );
@@ -217 +216 @@
- *  file = The name of the file that signaled this error.
- *  line = The line number on which this error occurred.
+ *  msg  = An error message supplied by the user.
- */
-extern (C) void onAssertErrorMsg( char[] file, uint line, char[] msg )
-{
-!assertHandler
+assertHandler is null
-        throw new AssertException( msg, file, line );
-    assertHandler( file, line, msg );
@@ -240 +240 @@
-extern (C) bool onCollectResource( Object obj )
-{
-!collectHandler
+collectHandler is null
-        return true;
-    return collectHandler( obj );

trunk/src/ares/std/thread.d

@@ -76 +76 @@
-        // entry point for Windows threads
-        //
-Func
+_entryPoint
-        {
-            Thread  obj = cast(Thread) arg;
@@ -160 +160 @@
-        // entry point for POSIX threads
-        //
-Func
+_entryPoint
-        {
-            Thread  obj = cast(Thread) arg;
@@ -177 +177 @@
-            // an exception is in-flight?
-
-           static extern (C) void 
+            extern (C) void thread_
-            {
-                Thread  obj = Thread.getThis();
@@ -194 +194 @@
-
-            pthread_cleanup cleanup;
-           cleanup.push( &
+            cleanup.push( &thread_
-
-            try
@@ -214 +214 @@
-
-
-
+thread_
-        in
-        {
@@ -283 +283 @@
-
-
-
+thread_
-        in
-        {
@@ -423 +423 @@
-
-
+    /**
+     * Cleans up any remaining resources used by this object.
+     */
+    ~this()
+    {
+        if( m_addr == m_addr.init )
+        {
+            return;
+        }
+
+        version( Win32 )
+        {
+            m_addr = m_addr.init;
+            CloseHandle( m_hndl );
+            m_hndl = m_hndl.init;
+        }
+        else version( Posix )
+        {
+            pthread_detach( m_addr );
+            m_addr = m_addr.init;
+        }
+    }
+
+
-    ////////////////////////////////////////////////////////////////////////////
-    // General Actions
@@ -450 +474 @@
-            version( Win32 )
-            {
-Func
+_entryPoint
-                if( cast(size_t) m_hndl == 0 )
-                    throw new ThreadException( "Error creating thread" );
@@ -459 +483 @@
-                scope( failure ) m_isRunning = false;
-
-Func
+_entryPoint
-                    throw new ThreadException( "Error creating thread" );
-            }
@@ -480 +504 @@
-            if( WaitForSingleObject( m_hndl, INFINITE ) != WAIT_OBJECT_0 )
-                throw new ThreadException( "Unable to join thread" );
+            // NOTE: m_addr must be cleared before m_hndl is closed to avoid
+            //       a race condition with isRunning.  The operation is labeled
+            //       volatile to prevent compiler reordering.
+            volatile m_addr = m_addr.init;
+            CloseHandle( m_hndl );
+            m_hndl = m_hndl.init;
-        }
-        else version( Posix )
@@ -485 +515 @@
-            if( pthread_join( m_addr, null ) != 0 )
-                throw new ThreadException( "Unable to join thread" );
+            // NOTE: pthread_join acts as a substitute for pthread_detach,
+            //       which is normally called by the dtor.  Setting m_addr
+            //       to zero ensures that pthread_detach will not be called
+            //       on object destruction.
+            volatile m_addr = m_addr.init;
-        }
-    }
@@ -532 +567 @@
-    final bool isRunning()
-    {
-!m_addr
+m_addr == m_addr.init
-        {
-            return false;
@@ -906 +941 @@
-    {
-        assert( t.m_next || t.m_prev );
+        version( Win32 )
+        {
+            // NOTE: This doesn't work for Posix as m_isRunning must be set to
+            //       false after the thread is removed during normal execution.
-        assert( !t.isRunning );
+    }
-    }
-    body
@@ -926 +966 @@
-        //       and having m_next and m_prev be non-null is a good way to
-        //       ensure that.
-
-        // NOTE: Cleanup of any thread resources should occur as soon as the
-        //       thread is detected to no longer be running, and this seemed
-        //       like the most reasonable place to do so.
-        version( Win32 )
-        {
-            CloseHandle( t.m_hndl );
-            t.m_hndl = t.m_hndl.init;
-            t.m_addr = t.m_addr.init;
-        }
-        else version( Posix )
-        {
-            pthread_detach( t.m_addr );
-            t.m_addr = t.m_addr.init;
-        }
-    }
-
@@ -1013 +1038 @@
-        else
-            sigusr1.sa_flags   = 0;
-
+thread_
-        // NOTE: We want to ignore all signals while in this handler, so fill
-        //       sa_mask to indicate this.
@@ -1023 +1048 @@
-        //       restart.
-        sigusr2.sa_flags   = 0;
-
+thread_
-        // NOTE: We want to ignore all signals while in this handler, so fill
-        //       sa_mask to indicate this.
@@ -1134 +1159 @@
-            }
-
-           CONTEXT context
+            CONTEXT context = void
-            context.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL;
-

trunk/src/ares/std/traits.d

@@ -71 +71 @@
-template isPointerType( T )
-{
-
+
+
+
+
+
+
+
+
+
+
+
-                               is( T == class )     ||
-                               is( T == interface ) ||
-                               isFunctionPointerType!( T ) ||
-                               is( T == delegate );
-}
@@ -84 +93 @@
-template isCallableType( T )
-{
-
+
+
-                                is( T == delegate ) ||
-                                is( typeof(T.opCall) == function );
-}
-
-
-//
-// NOTE: This template is a hack to use in place of "is(T==function)" since
-//       it actually detects a function alias, not a function pointer.
-//
-private template isFunctionPointerType( T )
-{
-    const bool isFunctionPointerType = T.mangleof.length > 2 &&
-                                       T.mangleof[0] == 'P'  &&
-                                       T.mangleof[1] == 'F';
-}

trunk/src/ares/std/unicode.d

@@ -79 +79 @@
-        is returned.
-
-
-LINK http://www.utf-8.com/
-LINK http://www.hackcraft.net/xmlUnicode/
-LINK http://www.azillionmonkeys.com/qed/unicode.html/
-LINK http://icu.sourceforge.net/docs/papers/forms_of_unicode/
+:
+UL $(LINK http://www.utf-8.com/)
+UL $(LINK http://www.hackcraft.net/xmlUnicode/)
+UL $(LINK http://www.azillionmonkeys.com/qed/unicode.html/)
+UL $(LINK http://icu.sourceforge.net/docs/papers/forms_of_unicode/)
-
-*******************************************************************************/
@@ -111 +111 @@
-        char[] output;
-
-w
+        
-
-        // reset output after a realloc
@@ -587 +587 @@
-{
-    /**
+     * Transcodes the UTF string src to the UTF format required by dst.
-     *
+     * Params:
+     *  src = The source string to convert.
+     *  dst = The destination buffer.
+     *  ate = The number of elements consumed from src.
+     *
+     * Returns:
+     *  The converted string.
+     *
+     * Throws:
+     *  UnicodeException.
-     */
-x
+src
-    {
-        static if (is (DstElem == FromElem))
-        {
-x
+src
-        }
-        else
@@ -601 +612 @@
-            static if (is (DstElem == char))
-            {
-x
+src
-            }
-            else static if (is (DstElem == wchar))
-            {
-x
+src
-            }
-            else static if (is (DstElem == dchar))
-            {
-x
+src
-            }
-            else
-            {
-
-
+
-            }
-            if (ate)

trunk/src/ares/std/vararg.d

@@ -15 +15 @@
-
-
+/**
+ * The base vararg list type.
+ */
-alias void* va_list;
-
-
+template va_start( T )
+{
-/**
+     * This function initializes the supplied argument pointer for subsequent
+     * use by va_arg and va_end.
- *
+     * Params:
+     *  ap      = The argument pointer to initialize.
+     *  paramn  = The identifier of the rightmost parameter in the function
+     *            parameter list.
- */
-template va_start(T)
-{
-    void va_start(out va_list ap, inout T parmn)
-    {
@@ -30 +39 @@
-
-
+template va_arg( T )
+{
-/**
+     * This function returns the next argument in the sequence referenced by
+     * the supplied argument pointer.  The argument pointer will be adjusted
+     * to point to the next arggument in the sequence.
+     *
+     * Params:
+     *  ap  = The argument pointer.
- *
+     * Returns:
+     *  The next argument in the sequence.  The result is undefined if ap
+     *  does not point to a valid argument.
- */
-template va_arg(T)
-{
-    T va_arg(inout va_list ap)
-    {
@@ -45 +63 @@
-
-/**
+ * This function cleans up any resources allocated by va_start.  It is
+ * currently a no-op and exists mostly for syntax compatibility with
+ * the variadric argument functions for C.
- *
+ * Params:
+ *  ap  = The argument pointer.
- */
-void va_end(va_list ap)
@@ -54 +77 @@
-
-/**
+ * This function copied the argument pointer src to dst.
- *
+ * Params:
+ *  src = The source pointer.
+ *  dst = The destination pointer.
- */
-out va_list dest, va_list src
+ out va_list dst, va_list src 
-{
-e
+
-}