[LbmBenchmarkKernelsPublic.git] / src / Memory.c

// --------------------------------------------------------------------------
//
// Copyright
//   Markus Wittmann, 2016-2017
//   RRZE, University of Erlangen-Nuremberg, Germany
//   markus.wittmann -at- fau.de or hpc -at- rrze.fau.de
//
//   Viktor Haag, 2016
//   LSS, University of Erlangen-Nuremberg, Germany
//
//   Michael Hussnaetter, 2017-2018
//   University of Erlangen-Nuremberg, Germany
//   michael.hussnaetter -at- fau.de
//
//  This file is part of the Lattice Boltzmann Benchmark Kernels (LbmBenchKernels).
//
//  LbmBenchKernels is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  LbmBenchKernels is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with LbmBenchKernels.  If not, see <http://www.gnu.org/licenses/>.
//
// --------------------------------------------------------------------------
// TODO: make configurable
#define HAVE_HUGE_PAGES


#ifdef HAVE_HUGE_PAGES
#define _BSD_SOURCE
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>  // strerror
#include <errno.h>


#ifdef HAVE_MEMKIND
#include <hbwmalloc.h>
#endif

#ifdef HAVE_HUGE_PAGES
#include <sys/mman.h> // madvise
#endif

#include "Base.h"
#include "Memory.h"


int MemAlloc(void ** ptr, size_t bytesToAlloc)
{
	void * tmpPtr;

	tmpPtr = malloc(bytesToAlloc);

	if (tmpPtr == NULL) { //  && bytesToAlloc != 0) {
		Error("allocation of %lu bytes failed: %d - %s\n", bytesToAlloc, errno, strerror(errno));
		exit(1);
	}

	*ptr = tmpPtr;

	return 0;
}

int MemAllocAligned(void ** ptr, size_t bytesToAlloc, size_t alignmentBytes)
{
	int ret;

	ret = posix_memalign(ptr, alignmentBytes, bytesToAlloc);

	if (ret) {
		Error("allocation of %lu bytes aligned to %lu bytes failed: %d - %s\n", bytesToAlloc, alignmentBytes, errno, strerror(errno));
		exit(1);
	}

#ifdef HAVE_HUGE_PAGES

	if (alignmentBytes % 4096 == 0) {
		ret = madvise(*ptr, bytesToAlloc, MADV_HUGEPAGE);

		if (ret != 0) {
			DEBUG_BREAK_POINT();
			Error("madvise(%p, %lu, MADV_HUGEPAGE) failed: %d - %s.\n", *ptr, bytesToAlloc, errno, strerror(errno));
			exit(1);
		}
	}
#endif

	return 0;
}


int MemFree(void ** ptr)
{
	Assert(*ptr != NULL);

	free(*ptr);

	*ptr = NULL;

	return 0;
}

int MemZero(void * ptr, size_t bytesToZero)
{
	Assert(ptr != NULL);
	Assert(bytesToZero > 0);

	memset(ptr, 0, bytesToZero);

	return 0;
}

#ifdef HAVE_MEMKIND
int HbwAlloc(void ** ptr, size_t bytesToAlloc)
{
	void * tmpPtr;

	tmpPtr = hbw_malloc(bytesToAlloc);

	if (tmpPtr == NULL) { //  && bytesToAlloc != 0) {
		Error("allocation of %lu bytes in HBM failed: %d - %s\n", bytesToAlloc, errno, strerror(errno));
		exit(1);
	}

	*ptr = tmpPtr;

	return 0;
}

int HbwAllocAligned(void ** ptr, size_t bytesToAlloc, size_t alignmentBytes)
{
	int ret;

	ret = hbw_posix_memalign(ptr, alignmentBytes, bytesToAlloc);

	if (ret) {
		Error("allocation of %lu bytes in HBM aligned to %lu bytes failed: %d - %s\n", bytesToAlloc, alignmentBytes, errno, strerror(errno));
		exit(1);
	}

	return 0;
}


int HbwFree(void ** ptr)
{
	Assert(*ptr != NULL);

	hbw_free(*ptr);

	*ptr = NULL;

	return 0;
}

#endif	// HAVE_MEMKIND
Commit	Line	Data
10988083 MW	1	// --------------------------------------------------------------------------
	2	//
	3	// Copyright
	4	// Markus Wittmann, 2016-2017
	5	// RRZE, University of Erlangen-Nuremberg, Germany
	6	// markus.wittmann -at- fau.de or hpc -at- rrze.fau.de
	7	//
	8	// Viktor Haag, 2016
	9	// LSS, University of Erlangen-Nuremberg, Germany
	10	//
8cafd9ea MW	11	// Michael Hussnaetter, 2017-2018
	12	// University of Erlangen-Nuremberg, Germany
	13	// michael.hussnaetter -at- fau.de
	14	//
10988083 MW	15	// This file is part of the Lattice Boltzmann Benchmark Kernels (LbmBenchKernels).
	16	//
	17	// LbmBenchKernels is free software: you can redistribute it and/or modify
	18	// it under the terms of the GNU General Public License as published by
	19	// the Free Software Foundation, either version 3 of the License, or
	20	// (at your option) any later version.
	21	//
	22	// LbmBenchKernels is distributed in the hope that it will be useful,
	23	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	24	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	25	// GNU General Public License for more details.
	26	//
	27	// You should have received a copy of the GNU General Public License
	28	// along with LbmBenchKernels. If not, see <http://www.gnu.org/licenses/>.
	29	//
	30	// --------------------------------------------------------------------------
e3f82424 MW	31	// TODO: make configurable
	32	#define HAVE_HUGE_PAGES
	33
	34
	35	#ifdef HAVE_HUGE_PAGES
	36	#define _BSD_SOURCE
	37	#endif
	38
10988083 MW	39	#include <stdio.h>
	40	#include <stdlib.h>
	41	#include <string.h> // strerror
	42	#include <errno.h>
	43
e3f82424	44
8cafd9ea MW	45	#ifdef HAVE_MEMKIND
	46	#include <hbwmalloc.h>
	47	#endif
	48
e3f82424 MW	49	#ifdef HAVE_HUGE_PAGES
	50	#include <sys/mman.h> // madvise
	51	#endif
	52
10988083 MW	53	#include "Base.h"
	54	#include "Memory.h"
	55
	56
	57	int MemAlloc(void ** ptr, size_t bytesToAlloc)
	58	{
	59	void * tmpPtr;
	60
	61	tmpPtr = malloc(bytesToAlloc);
	62
	63	if (tmpPtr == NULL) { // && bytesToAlloc != 0) {
	64	Error("allocation of %lu bytes failed: %d - %s\n", bytesToAlloc, errno, strerror(errno));
	65	exit(1);
	66	}
	67
	68	*ptr = tmpPtr;
	69
	70	return 0;
	71	}
	72
	73	int MemAllocAligned(void ** ptr, size_t bytesToAlloc, size_t alignmentBytes)
	74	{
	75	int ret;
	76
	77	ret = posix_memalign(ptr, alignmentBytes, bytesToAlloc);
	78
	79	if (ret) {
	80	Error("allocation of %lu bytes aligned to %lu bytes failed: %d - %s\n", bytesToAlloc, alignmentBytes, errno, strerror(errno));
	81	exit(1);
	82	}
	83
e3f82424 MW	84	#ifdef HAVE_HUGE_PAGES
	85
	86	if (alignmentBytes % 4096 == 0) {
	87	ret = madvise(*ptr, bytesToAlloc, MADV_HUGEPAGE);
	88
	89	if (ret != 0) {
	90	DEBUG_BREAK_POINT();
	91	Error("madvise(%p, %lu, MADV_HUGEPAGE) failed: %d - %s.\n", *ptr, bytesToAlloc, errno, strerror(errno));
	92	exit(1);
	93	}
	94	}
	95	#endif
	96
10988083 MW	97	return 0;
	98	}
	99
	100
	101	int MemFree(void ** ptr)
	102	{
	103	Assert(*ptr != NULL);
	104
	105	free(*ptr);
	106
	107	*ptr = NULL;
	108
	109	return 0;
	110	}
	111
	112	int MemZero(void * ptr, size_t bytesToZero)
	113	{
	114	Assert(ptr != NULL);
	115	Assert(bytesToZero > 0);
	116
	117	memset(ptr, 0, bytesToZero);
	118
	119	return 0;
	120	}
8cafd9ea MW	121
	122	#ifdef HAVE_MEMKIND
	123	int HbwAlloc(void ** ptr, size_t bytesToAlloc)
	124	{
	125	void * tmpPtr;
	126
	127	tmpPtr = hbw_malloc(bytesToAlloc);
	128
	129	if (tmpPtr == NULL) { // && bytesToAlloc != 0) {
	130	Error("allocation of %lu bytes in HBM failed: %d - %s\n", bytesToAlloc, errno, strerror(errno));
	131	exit(1);
	132	}
	133
	134	*ptr = tmpPtr;
	135
	136	return 0;
	137	}
	138
	139	int HbwAllocAligned(void ** ptr, size_t bytesToAlloc, size_t alignmentBytes)
	140	{
	141	int ret;
	142
	143	ret = hbw_posix_memalign(ptr, alignmentBytes, bytesToAlloc);
	144
	145	if (ret) {
	146	Error("allocation of %lu bytes in HBM aligned to %lu bytes failed: %d - %s\n", bytesToAlloc, alignmentBytes, errno, strerror(errno));
	147	exit(1);
	148	}
	149
	150	return 0;
	151	}
	152
	153
	154	int HbwFree(void ** ptr)
	155	{
	156	Assert(*ptr != NULL);
	157
	158	hbw_free(*ptr);
	159
	160	*ptr = NULL;
	161
	162	return 0;
	163	}
	164
	165	#endif // HAVE_MEMKIND