Use getpagesize() instead of PAGE_SIZE macro when KMP_OS_LINUX is true

[vhscampos]

Summary

Following the TODO comment in kmp_alloc.cpp line 1723, I replaced the usage of said macro (in kmp_runtime.c) by a call to getpagesize() when KMP_OS_LINUX is true.

[jlpeyton]

Inside kmp_os.h (around the PAGE_SIZE code), could you have:

#if KMP_OS_LINUX
# define KMP_GET_PAGE_SIZE() getpagesize()
#else
# define KMP_GET_PAGE_SIZE() PAGE_SIZE
#endif

And then const int page_size = KMP_GET_PAGE_SIZE() inside kmp_alloc.c and kmp_runtime.c

[vhscampos]

I have applied the suggestions.

[jlpeyton]

LGTM and thanks for the patch! Do I need to commit on your behalf?

[vhscampos]

Yes, thanks.

runtime/src/kmp_alloc.c

___kmp_allocate( size_t size KMP_SRC_LOC_DECL )
     return ptr;
 } // func ___kmp_allocate
 
 #if (BUILD_MEMORY==FIRST_TOUCH)
 void *
 __kmp_ft_page_allocate(size_t size)
 {
   void *adr, *aadr;
-#if KMP_OS_LINUX
-  /* TODO: Use this function to get page size everywhere */
-  int page_size = getpagesize();
-#else
-  /* TODO: Find windows function to get page size and use it everywhere */
-  int page_size = PAGE_SIZE;
-#endif /* KMP_OS_LINUX */
+
+  const int page_size = KMP_GET_PAGE_SIZE();
 
   adr = (void *) __kmp_thread_malloc( __kmp_get_thread(),
                                     size + page_size + KMP_PTR_SKIP);
   if ( adr == 0 )
     KMP_FATAL( OutOfHeapMemory );
 
   /* check to see if adr is on a page boundary. */
   if ( ( (kmp_uintptr_t) adr & (page_size - 1)) == 0)

runtime/src/kmp_os.h

 
 #define KMP_EXPORT  extern  /* export declaration in guide libraries */
 
 #if __GNUC__ >= 4
     #define __forceinline __inline
 #endif
 
 #define PAGE_SIZE                       (0x4000)
+
+#if KMP_OS_LINUX
+#define KMP_GET_PAGE_SIZE() getpagesize()
+#else
+// TODO: find the corresponding function to getpagesize() in Windows
+// and use it whenever possible.
+#define KMP_GET_PAGE_SIZE() PAGE_SIZE
+#endif
+
 #define PAGE_ALIGNED(_addr)     ( ! ((size_t) _addr & \
-                                     (size_t)(PAGE_SIZE - 1)))
-#define ALIGN_TO_PAGE(x)   (void *)(((size_t)(x)) & ~((size_t)(PAGE_SIZE - 1)))
+                                     (size_t)(KMP_GET_PAGE_SIZE() - 1)))
+#define ALIGN_TO_PAGE(x)   (void *)(((size_t)(x)) & ~((size_t)(KMP_GET_PAGE_SIZE() - 1)))
 
 /* ---------------------- Support for cache alignment, padding, etc. -----------------*/
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
 #define INTERNODE_CACHE_LINE 4096 /* for multi-node systems */

runtime/src/kmp_runtime.c

if(gtid >= 0) {
                 node = __kmp_get_host_node(p1);
                 if(node < 0)  /* doesn't work, so don't try this next time */
                     __kmp_storage_map_verbose = FALSE;
                 else {
                     char *last;
                     int lastNode;
                     int localProc = __kmp_get_cpu_from_gtid(gtid);
 
-                    p1 = (void *)( (size_t)p1 & ~((size_t)PAGE_SIZE - 1) );
-                    p2 = (void *)( ((size_t) p2 - 1) & ~((size_t)PAGE_SIZE - 1) );
+                    const int page_size = KMP_GET_PAGE_SIZE();
+
+                    p1 = (void *)( (size_t)p1 & ~((size_t)page_size - 1) );
+                    p2 = (void *)( ((size_t) p2 - 1) & ~((size_t)page_size - 1) );
                     if(localProc >= 0)
                         __kmp_printf_no_lock("  GTID %d localNode %d\n", gtid, localProc>>1);
                     else
                         __kmp_printf_no_lock("  GTID %d\n", gtid);
 # if KMP_USE_PRCTL
 /* The more elaborate format is disabled for now because of the prctl hanging bug. */
                     do {
                         last = p1;
                         lastNode = node;
                         /* This loop collates adjacent pages with the same host node. */
                         do {
-                            (char*)p1 += PAGE_SIZE;
+                            (char*)p1 += page_size;
                         } while(p1 <= p2 && (node = __kmp_get_host_node(p1)) == lastNode);
                         __kmp_printf_no_lock("    %p-%p memNode %d\n", last,
                                              (char*)p1 - 1, lastNode);
                     } while(p1 <= p2);
 # else
                     __kmp_printf_no_lock("    %p-%p memNode %d\n", p1,
-                                         (char*)p1 + (PAGE_SIZE - 1), __kmp_get_host_node(p1));
+                                         (char*)p1 + (page_size - 1), __kmp_get_host_node(p1));
                     if(p1 < p2)  {
                         __kmp_printf_no_lock("    %p-%p memNode %d\n", p2,
-                                             (char*)p2 + (PAGE_SIZE - 1), __kmp_get_host_node(p2));
+                                             (char*)p2 + (page_size - 1), __kmp_get_host_node(p2));
                     }
 # endif
                 }
             }
         } else
             __kmp_printf_no_lock("  %s\n", KMP_I18N_STR( StorageMapWarning ) );
     }
 #endif /* KMP_PRINT_DATA_PLACEMENT */