Make compile with NVM_EXT work with precompiler version 14.

Fixed bug in NVM_ALIGN macro.

Persistent structs are initialized before the address is put into a
pointer to persistent struct so that nvm_verify calls all work.

Use shapeof() rather than presume the global name of an nvm_type 
definition under NVM_EXT compile.

Use a better hash function in nvm_pick_mutex.

Implement nvm_get_mutex to get a mutex by index from an 
nvm_mutex_array.

Add const where needed.

Lack of a root object indicates an uninitialized region rather than 
an invalid USID in nvm_region struct.

Change the USID for nvm_region since this library version does not 
work with previous region files.

Author: whbridge

nvmd/nvm_heap.c

@@ -448,10 +448,10 @@ extern "C"
      */
 #ifdef NVM_EXT
 #define NVM_ALLOC(heap, type, count) \
-        ((type^)nvm_alloc((heap), shapeof(type), (count))
+        ((type^)nvm_alloc((heap), shapeof(type), (count)))
 #else
 #define NVM_ALLOC(heap, type, count) \
-    ((type*)nvm_alloc((heap), shapeof(type), (count))
+    ((type*)nvm_alloc((heap), shapeof(type), (count)))
 #endif //NVM_EXT
 
     /**

nvmd/nvm_heap.h

@@ -98,8 +98,8 @@ extern "C"
         nvm_blk_srp back; // ^nvm_blk    
     };
     typedef struct nvm_link nvm_link;
+    extern const nvm_type nvm_type_nvm_link;
 #endif //NVM_EXT
-    extern const nvm_type nvm_type_nvm_link; //#
 
     /**
      * This is a list of doubly linked  nvm_blk structs. It is embedded in

nvmd/nvm_heap0.h

@@ -387,7 +387,7 @@ nvm_mutex_array *nvm_create_mutex_array(
 #ifdef NVM_EXT
 nvm_mutex ^nvm_pick_mutex@(
     nvm_mutex_array ^array,
-    void ^ptr
+    const void ^ptr
     )
 {
     /* get the region for the array and ptr from the current transaction */
@@ -408,15 +408,15 @@ nvm_mutex ^nvm_pick_mutex@(
      * address. */
     size_t offset = (uint8_t^)ptr - (uint8_t^)rg;
 
-    /* divide offset by a prime that is less than the alignment of heap
-     * allocation to get an even distribution across the mutexes. Use that
+    /* divide offset by a prime that is less than the alignment of most
+     * pointers to get an even distribution across the mutexes. Use that
      * to select the mutex. */
-    return (nvm_mutex ^)%array=>mutexes[(offset/61) % array=>count];
+    return (nvm_mutex ^)%array=>mutexes[(offset/7) % array=>count];
 }
 #else
 nvm_mutex *nvm_pick_mutex(
     nvm_mutex_array *array,
-    void *ptr
+    const void *ptr
     )
 {
     /* get the region for the array and ptr from the current transaction */
@@ -437,12 +437,13 @@ nvm_mutex *nvm_pick_mutex(
      * address. */
     size_t offset = (uint8_t*)ptr - (uint8_t*)rg;
 
-    /* divide offset by a prime that is less than the alignment of heap
-     * allocation to get an even distribution across the mutexes. Use that
+    /* divide offset by a prime that is less than the alignment of most
+     * pointers to get an even distribution across the mutexes. Use that
      * to select the mutex. */
-    return (nvm_mutex *)&array->mutexes[(offset/61) % array->count];
+    return (nvm_mutex *)&array->mutexes[(offset/7) % array->count];
 }
 #endif //NVM_EXT
+
 /**
  * Find the wait table bucket for an NVM mutex and acquire its mutex.
  * @param tx

nvmd/nvm_locks.c

@@ -191,12 +191,40 @@ NVM_SRP(nvm_mutex) // define self-relative pointer operations
 #ifdef NVM_EXT
     nvm_mutex ^nvm_pick_mutex@(
         nvm_mutex_array ^array,
-        void ^ptr
+        const void ^ptr
         );
 #else
     nvm_mutex *nvm_pick_mutex(
         nvm_mutex_array *array,
-        void *ptr
+        const void *ptr
+        );
+#endif //NVM_EXT
+
+    /**
+     * Get one mutex from a mutex array by an index into the array. A pointer
+     * to the mutex is returned. If the index is past the end of the array a
+     * null pointer is returned. This must be called in a transaction. Any
+     * errors will fire an assert. This is useful for acquiring all the
+     * mutexes one at a time.
+     *
+     * @param[in] array
+     * The mutex array to pick from
+     *
+     * @param[in] index
+     * Index into the array of the mutex to return
+     *
+     * @return
+     * Pointer to the chosen mutex or null if there is none
+     */
+#ifdef NVM_EXT
+    nvm_mutex ^nvm_get_mutex@(
+        nvm_mutex_array ^array,
+        uint32_t index
+        );
+#else
+    nvm_mutex *nvm_get_mutex(
+        nvm_mutex_array *array,
+        uint32_t index
         );
 #endif //NVM_EXT
 
@@ -221,7 +249,6 @@ NVM_SRP(nvm_mutex) // define self-relative pointer operations
         );
 #endif //NVM_EXT
 
-
     /**
      * This acquires an NVM lock and hangs it on the current transaction.  The
      * lock may be a shared or exclusive lock. If the lock is successfully

nvmd/nvm_locks.h

@@ -251,7 +251,7 @@ void nvm_thread_fini(void)
  */
 #ifdef NVM_EXT
 void nvm_flush(
-        void ^ptr, 
+        const void ^ptr,
         size_t bytes
         )
 {
@@ -313,7 +313,7 @@ void nvm_flush(
 }
 #else
 void nvm_flush(
-        void *ptr,    
+        const void *ptr,
         size_t bytes
         )
 {
@@ -384,7 +384,7 @@ void nvm_flush(
  */
 #ifdef NVM_EXT
 void nvm_flush1(
-        void ^ptr 
+        const void ^ptr
         )
 {
     nvm_thread_data *td = nvm_get_thread_data();
@@ -434,7 +434,7 @@ void nvm_flush1(
 }
 #else
 void nvm_flush1(
-        void *ptr    
+        const void *ptr
         )
 {
     nvm_thread_data *td = nvm_get_thread_data();
@@ -484,87 +484,6 @@ void nvm_flush1(
 }
 #endif //NVM_EXT
 
-/**
- * This does an immediate flush of a range of bytes rather than just saving
- * the address for flushing before next persist. This has less overhead
- * than scheduling the flush, but the data is lost from the processor cache.
- * 
- * @param[in] ptr
- * The is the first byte of NVM to flush from caches
- * 
- * @param[in] bytes
- * The number of bytes to flush. Pass zero to flush just one cache line.
- */
-#ifdef NVM_EXT
-void nvm_flushi(
-        void ^ptr, 
-        size_t bytes
-        )
-{
-    /* Optimize case of just one cache line */
-    if (bytes == 0)
-    {
-        nvms_flush((uint64_t)ptr);
-        return;
-    }
-
-    /* need to get the cache line size to decide how many cache lines need
-     * flushing. */
-    nvm_app_data *ad = nvm_get_app_data();
-    uint64_t clsz = ad->params.cache_line; // cache line size
-
-    /* Align to a cache line boundary to ensure all cache lines are covered */
-    uint64_t addr = (uint64_t)ptr;
-    uint64_t off = addr & (clsz - 1);
-    addr -= off;
-    bytes += off;
-
-    /* loop flushing one cache line each time around. */
-    while (1)
-    {
-        nvms_flush(addr);
-        if (bytes <= clsz)
-            return;
-        addr += clsz;
-        bytes -= clsz;
-    }
-}
-#else
-void nvm_flushi(
-        void *ptr,    
-        size_t bytes
-        )
-{
-    /* Optimize case of just one cache line */
-    if (bytes == 0)
-    {
-        nvms_flush((uint64_t)ptr);
-        return;
-    }
-
-    /* need to get the cache line size to decide how many cache lines need
-     * flushing. */
-    nvm_app_data *ad = nvm_get_app_data();
-    uint64_t clsz = ad->params.cache_line; // cache line size
-
-    /* Align to a cache line boundary to ensure all cache lines are covered */
-    uint64_t addr = (uint64_t)ptr;
-    uint64_t off = addr & (clsz - 1);
-    addr -= off;
-    bytes += off;
-
-    /* loop flushing one cache line each time around. */
-    while (1)
-    {
-        nvms_flush(addr);
-        if (bytes <= clsz)
-            return;
-        addr += clsz;
-        bytes -= clsz;
-    }
-}
-#endif //NVM_EXT
-
 /**
  * This is a barrier that ensures all previous stores to NVM by the calling
  * thread are actually persistent when it returns. On some systems it is
@@ -670,7 +589,6 @@ void nvm_longjmp(
         nvms_assert_fail("Bad nvm_jmp_buf for nmv_longjmp");
     }
 
-
     /* Abort and end transactions until we are at the same depth as the
      * nvm_setjmp. */
     while (depth > buf->depth)
@@ -860,6 +778,6 @@ uint16_t nvm_cas2(
     return ret;
 }
 #endif
-    //TODO+ before calling nvms_corrupt mark the nvm_region as failed for
-    // corruption. Have a status that is the mechanism of the last detach:
-    // clean, assert, or corruption
+//TODO+ before calling nvms_corrupt mark the nvm_region as failed for
+//TODO+ corruption. Have a status that is the mechanism of the last detach:
+//TODO+ clean, assert, or corruption