Attachment #487508 for bug #600860

View | Details | Raw Unified | Return to bug 600860
Collapse All | Expand All




                 https://reviews.llvm.org/D35072
++ b/runtime/src/kmp_alloc.c

__kmp_ft_page_allocate(size_t size)
{
  void *adr, *aadr;

  const int page_size = KMP_GET_PAGE_SIZE();
  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 */

  adr = (void *) __kmp_thread_malloc( __kmp_get_thread(),
                                    size + page_size + KMP_PTR_SKIP);
++ b/runtime/src/kmp_os.h

    #define __forceinline __inline
#endif

#if KMP_OS_WINDOWS
#include <windows.h>

static inline int KMP_GET_PAGE_SIZE(void) {
    SYSTEM_INFO si;
    GetSystemInfo(&si);
    return si.dwPageSize;
}
#else
// TODO: find the corresponding function to getpagesize() in Windows
// and use it whenever possible.
#define KMP_GET_PAGE_SIZE() getpagesize()
#endif

#define PAGE_ALIGNED(_addr)     ( ! ((size_t) _addr & \
                                     (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. -----------------*/



#if KMP_ASM_INTRINS && KMP_OS_WINDOWS

#include <Windows.h>

#pragma intrinsic(InterlockedExchangeAdd)
#pragma intrinsic(InterlockedCompareExchange)
#pragma intrinsic(InterlockedExchange)
++ b/runtime/src/kmp_runtime.c

                    int lastNode;
                    int localProc = __kmp_get_cpu_from_gtid(gtid);

                    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

                        lastNode = node;
                        /* This loop collates adjacent pages with the same host node. */
                        do {
                            (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));
                    if(p1 < p2)  {
                        __kmp_printf_no_lock("    %p-%p memNode %d\n", p2,
                                             (char*)p2 + (page_size - 1), __kmp_get_host_node(p2));
                    }
# endif
                }

Return to bug 600860

Line Link Here

(-)file_not_specified_in_diff (-20 / +28 lines)
	https://reviews.llvm.org/D35072		https://reviews.llvm.org/D35072
1	-- a/runtime/src/kmp_alloc.c	1	++ b/runtime/src/kmp_alloc.c
Lines 1719-1731 Link Here
1719	__kmp_ft_page_allocate(size_t size)	1719	__kmp_ft_page_allocate(size_t size)
1720	{	1720	{
1721	void adr, aadr;	1721	void adr, aadr;
1722	#if KMP_OS_LINUX	1722
1723	/* TODO: Use this function to get page size everywhere */	1723	const int page_size = KMP_GET_PAGE_SIZE();
1724	int page_size = getpagesize();
1725	#else
1726	/* TODO: Find windows function to get page size and use it everywhere */
1727	int page_size = PAGE_SIZE;
1728	#endif /* KMP_OS_LINUX */
1729		1724
1730	adr = (void *) __kmp_thread_malloc( __kmp_get_thread(),	1725	adr = (void *) __kmp_thread_malloc( __kmp_get_thread(),
1731	size + page_size + KMP_PTR_SKIP);	1726	size + page_size + KMP_PTR_SKIP);
1732	-- a/runtime/src/kmp_os.h	1727	++ b/runtime/src/kmp_os.h
Lines 235-244 Link Here
235	#define __forceinline __inline	235	#define __forceinline __inline
236	#endif	236	#endif
237		237
238	#define PAGE_SIZE (0x4000)	238	#if KMP_OS_WINDOWS
		239	#include <windows.h>
		240
		241	static inline int KMP_GET_PAGE_SIZE(void) {
		242	SYSTEM_INFO si;
		243	GetSystemInfo(&si);
		244	return si.dwPageSize;
		245	}
		246	#else
		247	// TODO: find the corresponding function to getpagesize() in Windows
		248	// and use it whenever possible.
		249	#define KMP_GET_PAGE_SIZE() getpagesize()
		250	#endif
		251
239	#define PAGE_ALIGNED(_addr) ( ! ((size_t) _addr & \	252	#define PAGE_ALIGNED(_addr) ( ! ((size_t) _addr & \
240	(size_t)(PAGE_SIZE - 1)))	253	(size_t)(KMP_GET_PAGE_SIZE() - 1)))
241	#define ALIGN_TO_PAGE(x) (void *)(((size_t)(x)) & ~((size_t)(PAGE_SIZE - 1)))	254	#define ALIGN_TO_PAGE(x) (void *)(((size_t)(x)) & ~((size_t)(KMP_GET_PAGE_SIZE() - 1)))
242		255
243	/* ---------------------- Support for cache alignment, padding, etc. -----------------*/	256	/* ---------------------- Support for cache alignment, padding, etc. -----------------*/
244		257
Lines 289-296 Link Here
289		302
290	#if KMP_ASM_INTRINS && KMP_OS_WINDOWS	303	#if KMP_ASM_INTRINS && KMP_OS_WINDOWS
291		304
292	#include <Windows.h>
293
294	#pragma intrinsic(InterlockedExchangeAdd)	305	#pragma intrinsic(InterlockedExchangeAdd)
295	#pragma intrinsic(InterlockedCompareExchange)	306	#pragma intrinsic(InterlockedCompareExchange)
296	#pragma intrinsic(InterlockedExchange)	307	#pragma intrinsic(InterlockedExchange)
297	-- a/runtime/src/kmp_runtime.c	308	++ b/runtime/src/kmp_runtime.c
Lines 345-352 Link Here
345	int lastNode;	345	int lastNode;
346	int localProc = __kmp_get_cpu_from_gtid(gtid);	346	int localProc = __kmp_get_cpu_from_gtid(gtid);
347		347
348	p1 = (void *)( (size_t)p1 & ~((size_t)PAGE_SIZE - 1) );	348	const int page_size = KMP_GET_PAGE_SIZE();
349	p2 = (void *)( ((size_t) p2 - 1) & ~((size_t)PAGE_SIZE - 1) );	349
		350	p1 = (void *)( (size_t)p1 & ~((size_t)page_size - 1) );
		351	p2 = (void *)( ((size_t) p2 - 1) & ~((size_t)page_size - 1) );
350	if(localProc >= 0)	352	if(localProc >= 0)
351	__kmp_printf_no_lock(" GTID %d localNode %d\n", gtid, localProc>>1);	353	__kmp_printf_no_lock(" GTID %d localNode %d\n", gtid, localProc>>1);
352	else	354	else
Lines 358-374 Link Here
358	lastNode = node;	360	lastNode = node;
359	/* This loop collates adjacent pages with the same host node. */	361	/* This loop collates adjacent pages with the same host node. */
360	do {	362	do {
361	(char*)p1 += PAGE_SIZE;	363	(char*)p1 += page_size;
362	} while(p1 <= p2 && (node = __kmp_get_host_node(p1)) == lastNode);	364	} while(p1 <= p2 && (node = __kmp_get_host_node(p1)) == lastNode);
363	__kmp_printf_no_lock(" %p-%p memNode %d\n", last,	365	__kmp_printf_no_lock(" %p-%p memNode %d\n", last,
364	(char*)p1 - 1, lastNode);	366	(char*)p1 - 1, lastNode);
365	} while(p1 <= p2);	367	} while(p1 <= p2);
366	# else	368	# else
367	__kmp_printf_no_lock(" %p-%p memNode %d\n", p1,	369	__kmp_printf_no_lock(" %p-%p memNode %d\n", p1,
368	(char*)p1 + (PAGE_SIZE - 1), __kmp_get_host_node(p1));	370	(char*)p1 + (page_size - 1), __kmp_get_host_node(p1));
369	if(p1 < p2) {	371	if(p1 < p2) {
370	__kmp_printf_no_lock(" %p-%p memNode %d\n", p2,	372	__kmp_printf_no_lock(" %p-%p memNode %d\n", p2,
371	(char*)p2 + (PAGE_SIZE - 1), __kmp_get_host_node(p2));	373	(char*)p2 + (page_size - 1), __kmp_get_host_node(p2));
372	}	374	}
373	# endif	375	# endif
374	}	376	}