/* * Copyright (c) 2011-2013, Los Alamos National Security, LLC. * All rights Reserved. * * Copyright 2011-2012. Los Alamos National Security, LLC. This software was produced * under U.S. Government contract DE-AC52-06NA25396 for Los Alamos National * Laboratory (LANL), which is operated by Los Alamos National Security, LLC * for the U.S. Department of Energy. The U.S. Government has rights to use, * reproduce, and distribute this software. NEITHER THE GOVERNMENT NOR LOS * ALAMOS NATIONAL SECURITY, LLC MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR * ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified * to produce derivative works, such modified software should be clearly marked, * so as not to confuse it with the version available from LANL. * * Additionally, redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the Los Alamos National Security, LLC, Los Alamos * National Laboratory, LANL, the U.S. Government, nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE LOS ALAMOS NATIONAL SECURITY, LLC AND * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LOS ALAMOS NATIONAL * SECURITY, LLC OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * * CLAMR -- LA-CC-11-094 * This research code is being developed as part of the * 2011 X Division Summer Workshop for the express purpose * of a collaborative code for development of ideas in * the implementation of AMR codes for Exascale platforms * * AMR implementation of the Wave code previously developed * as a demonstration code for regular grids on Exascale platforms * as part of the Supercomputing Challenge and Los Alamos * National Laboratory * * Authors: Bob Robey XCP-2 brobey@lanl.gov * */ #ifndef MALLOCPLUS_H_ #define MALLOCPLUS_H_ #include #include #include #ifdef HAVE_CONFIG_H #include #endif #define HOST_REGULAR_MEMORY 0x00000 #define HOST_MANAGED_MEMORY 0x00001 #define DEVICE_REGULAR_MEMORY 0x00002 #define INDEX_ARRAY_MEMORY 0x00004 #define LOAD_BALANCE_MEMORY 0x00008 #define RESTART_DATA 0x00010 #define REPLICATED_DATA 0x00020 #define DISTRIBUTED_INT_DATA 0x00040 #define DISTRIBUTED_DOUBLE_DATA 0x00080 #if defined(HAVE_MPI) #include "mpi.h" #if defined(HAVE_J7) #include "j7/j7.h" #endif #endif using namespace std; /****************************************************************//** * \brief * Memory entry with fields for each entry in database *******************************************************************/ struct malloc_plus_memory_entry { void *mem_ptr; //!< memory pointer for entry size_t mem_capacity; //!< allocated capacity for memory buffer //!< this may be larger than the number of //!< elements and is used to internally handle //!< memory resizing size_t *mem_nelem; //!< number of elements size_t mem_ndims; //!< number of dimensions size_t mem_elsize; //!< element size for type of data int mem_flags; //!< flags for special handling char *mem_name; //!< name of memory entry }; struct cmp_str { bool operator()(const string &a, const string &b) { return a.compare(b) < 0; } }; /****************************************************************//** * MallocPlus class * Provide an enhanced memory allocation package with database * of allocations, sizes and contiguous memory allocations for * multi-dimensional arrays *******************************************************************/ class MallocPlus { //protected: public: map memory_name_dict; //!< Dictionary entries by name map memory_ptr_dict; //!< Dictionary entries by pointer #if defined(HAVE_MPI) && defined(HAVE_J7) private: J7 *j7; #endif public: // if we have MPI support enable these routines. they only really do anything // if we also have j7 support, but that's okay; we don't want ifdefs all // over. #if defined(HAVE_MPI) // parallel initialization routine void pinit(MPI_Comm smComm, std::size_t memPoolSize); // parallel finalization routine void pfini(void); #endif /****************************************************************//** * \brief * Allocates memory for a 1D array and put entry in database * * **Parameters** * * size_t nelem -- number of elements in array * * size_t elsize -- element size in bytes * * const char *name -- name of array * * int flags -- flags for special handling, default is 0 * * Typical Usage * * double *density = my_mem->memory_malloc(ncells, sizeof(double), * "Density"); *******************************************************************/ void *memory_malloc(size_t nelem, size_t elsize, const char *name, int flags=0); /****************************************************************//** * \brief * Duplicate memory and add new entry into database * * **Parameters** * * void *malloc_mem_ptr -- memory pointer to duplicate * * const char *addname -- new name for variable * * Typical Usage * * double *new_density = my_mem->memory_duplicate(density, "Density_new"); *******************************************************************/ void *memory_duplicate(void *malloc_mem_ptr, const char *addname); /****************************************************************//** * \brief * Reallocates memory for memory pointer in database * * **Parameters** * * size_t nelem -- number of elements for new allocation * * void *malloc_mem_ptr -- memory pointer to duplicate * * Typical Usage * * double *density = my_mem->memory_realloc(new_ncells, density); *******************************************************************/ void *memory_realloc(size_t nelem, void *malloc_mem_ptr); /****************************************************************//** * \brief * Reallocates memory for named entry in database * * **Parameters** * * size_t nelem -- number of elements for new allocation * * const char *name -- named entry to duplicate * * Typical Usage * * double *density = my_mem->memory_realloc(new_ncells, "Density"); *******************************************************************/ void *memory_realloc(size_t nelem, const char *name); /****************************************************************//** * \brief * Request memory buffer capacity reallocation for memory pointer in database. * This only changes the capacity for managed memory and does not change * the current number of elements registered for the array. * * **Parameters** * * size_t capacity -- capacity in number of elements for reallocation * * void *malloc_mem_ptr -- memory pointer to reallocate more capacity * * Typical Usage * * double *density = my_mem->memory_request(new_capacity, density); *******************************************************************/ void *memory_request(size_t new_capacity, void *malloc_mem_ptr); /****************************************************************//** * \brief * Request memory buffer capacity reallocation for named entry in database. * This only changes the capacity for managed memory and does not change * the current number of elements registered for the array. * * **Parameters** * * size_t capacity -- capacity in number of elements for reallocation * * const char *name -- named entry in database * * Typical Usage * * double *density = my_mem->memory_request(new_capacity, "Density"); *******************************************************************/ void *memory_request(size_t new_capacity, const char *name); /****************************************************************//** * \brief * Reallocates memory for all arrays in the database. Element size stays * the same. * * **Parameters** * * size_t nelem -- number of elements for new allocation * * Typical Usage * * my_mem->memory_realloc_all(new_ncells); *******************************************************************/ void memory_realloc_all(size_t nelem); /****************************************************************//** * \brief * Requests capacity reallocation for all arrays in the database. Element * size and number of elements stays the same. The maximum memory * capacity is increased. * * **Parameters** * * size_t capacity -- number of elements for new allocation * * Typical Usage * * my_mem->memory_realloc_all(new_capacity); *******************************************************************/ void memory_request_all(size_t new_capacity); /****************************************************************//** * \brief * Replaces a database entry with another database entry, effectively * renaming the entry and deallocating the memory for the old entry * and removing the other database entry. Both the return and the * first argument old memory pointer gets reset to the new memory * location. * * **Parameters** * * void *malloc_mem_ptr_old -- memory pointer to entry to replace * * void * const malloc_mem_ptr_new -- memory pointer to entry to * put in place of old memory * * Typical Usage * * double *density_new = (double *)my_mem->memory_malloc(new_ncells, * sizeof(double), "Density_new"); * ... lots of calculations of density_new from density (old) ... * density = (double *)my_mem->memory_replace(density, density_new); *******************************************************************/ void *memory_replace(void *malloc_mem_ptr_old, void * const malloc_mem_ptr_new); /****************************************************************//** * \brief * Swaps a database entry with another database entry, effectively * renaming both entries. The new pointers are returned in the * two arguments. * * **Parameters** * * void *malloc_mem_ptr_old -- memory pointer to swap * * void *malloc_mem_ptr_new -- memory pointer to swap * * Typical Usage * * int *level_old = (int *)my_mem->memory_malloc(new_ncells, * sizeof(int), "level_old"); * level = (int *)my_mem->memory_swap(&level, &level_old); * ... lots of calculations of level from level_new ... * my_mem->memory_delete(level_old); *******************************************************************/ void memory_swap(int **malloc_mem_ptr_old, int **malloc_mem_ptr_new); /****************************************************************//** * \brief * Swaps a database entry with another database entry, effectively * renaming both entries. The new pointers are returned in the * two arguments. * * **Parameters** * * void *malloc_mem_ptr_old -- memory pointer to swap * * void *malloc_mem_ptr_new -- memory pointer to swap * * Typical Usage * * float *density_old = (float *)my_mem->memory_malloc(new_ncells, * sizeof(float), "Density_old"); * density = (float *)my_mem->memory_swap(&density, &density_old); * ... lots of calculations of density from density_new ... * my_mem->memory_delete(density_old); *******************************************************************/ void memory_swap(float **malloc_mem_ptr_old, float **malloc_mem_ptr_new); /****************************************************************//** * \brief * Swaps a database entry with another database entry, effectively * renaming both entries. The new pointers are returned in the * two arguments. * * **Parameters** * * void *malloc_mem_ptr_old -- memory pointer to swap * * void *malloc_mem_ptr_new -- memory pointer to swap * * Typical Usage * * double *density_old = (double *)my_mem->memory_malloc(new_ncells, * sizeof(double), "Density_old"); * density = (double *)my_mem->memory_swap(&density, &density_old); * ... lots of calculations of density from density_new ... * my_mem->memory_delete(density_old); *******************************************************************/ void memory_swap(double **malloc_mem_ptr_old, double **malloc_mem_ptr_new); /****************************************************************//** * \brief * Adds an entry for an already allocated array into the database * * **Parameters** * * void *malloc_mem_ptr -- memory pointer to add * * size_t nelem -- number of elements in array * * size_t elsize -- element size in bytes * * const char *name -- name of array * * int flags -- flags for special handling, default is 0 * * Typical Usage * * double *density = my_mem->memory_add(density, ncells, sizeof(double), * "Density"); *******************************************************************/ void *memory_add(void *malloc_mem_ptr, size_t nelem, size_t elsize, const char *name, int flags=0); void *memory_add(void *malloc_mem_ptr, int ndim, size_t *nelem, size_t elsize, const char *name, int flags=0); /****************************************************************//** * \brief * Reorders all of the arrays in the database by the indices in the * iorder array. The reorder does the following: * tmp[ic] = density[iorder[ic]]; * SWAP_PTR(tmp, density); * Note that the pointer value will change during the operation and * will be returned in the return value. * * **Parameters** * * double *malloc_mem_ptr -- memory pointer to entry to reorder * * int *iorder -- index array for reordering * * Typical Usage * * double *density = my_mem->memory_reorder_all(density, iorder); *******************************************************************/ double *memory_reorder(double *malloc_mem_ptr, int *iorder); /****************************************************************//** * \brief * Reorders all of the arrays in the database by the indices in the * iorder array. The reorder does the following: * tmp[ic] = density[iorder[ic]]; * SWAP_PTR(tmp, density); * Note that the pointer value will change during the operation and * will be returned in the return value. * * **Parameters** * * float *malloc_mem_ptr -- memory pointer to entry to reorder * * int *iorder -- index array for reordering * * Typical Usage * * float *density = my_mem->memory_reorder_all(density, iorder); *******************************************************************/ float *memory_reorder(float *malloc_mem_ptr, int *iorder); /****************************************************************//** * \brief * Reorders all of the arrays in the database by the indices in the * iorder array. The reorder does the following: * tmp[ic] = level[iorder[ic]]; * SWAP_PTR(tmp, level); * Note that the pointer value will change during the operation and * will be returned in the return value. * * **Parameters** * * int *malloc_mem_ptr -- memory pointer to entry to reorder * * int *iorder -- index array for reordering * * Typical Usage * * int *level = my_mem->memory_reorder_all(level, iorder); *******************************************************************/ int *memory_reorder(int *malloc_mem_ptr, int *iorder); /****************************************************************//** * \brief * Reorders an index array in the database by the indices in the * iorder array and reindexes the array by the inverse order given * by inv_iorder. The reorder does the following: * tmp[ic] = inv_iorder[level[iorder[ic]]]; * SWAP_PTR(tmp, level); * Note that the pointer value will change during the operation and * will be returned in the return value. * * **Parameters** * * int *malloc_mem_ptr -- memory pointer to entry to reorder * * int *iorder -- index array for reordering * * int *inv_order -- inverse index array for reordering * * Typical Usage * * int *level = my_mem->memory_reorder_all(level, iorder, inv_iorder); *******************************************************************/ int *memory_reorder_indexarray(int *malloc_mem_ptr, int *iorder, int *inv_iorder); /****************************************************************//** * \brief * Reorders all of the arrays in the database by the indices in the * iorder array. The reorder does the following: * tmp[ic] = density[iorder[ic]]; * SWAP_PTR(tmp, density); * Note that the pointer value will change during the operation and * must be retrieved from the database. * * **Parameters** * * int *iorder -- index array for reordering * * Typical Usage * * my_mem->memory_reorder_all(iorder); *******************************************************************/ void memory_reorder_all(int *iorder); /****************************************************************//** * \brief * Prints out a report of all the arrays in the database. * * Typical Usage * * my_mem->memory_report(); *******************************************************************/ void memory_report(void); /****************************************************************//** * \brief * Deallocates memory for a memory pointer in the database and removes the * entry from the database. * * Typical Usage * * my_mem->memory_delete(density); *******************************************************************/ void *memory_delete(void *malloc_mem_ptr); /****************************************************************//** * \brief * Deallocates memory for a named entry in the database and removes the * entry from the database. * * Typical Usage * * my_mem->memory_delete("Density"); *******************************************************************/ void *memory_delete(const char *name); /****************************************************************//** * \brief * Deallocates memory for all arrays in the database. * * Typical Usage * * my_mem->memory_delete_all(); *******************************************************************/ void memory_delete_all(void); /****************************************************************//** * \brief * Removes the entry for a memory pointer from the database. (This does * not delete the memory). * * Typical Usage * * my_mem->memory_delete(density); *******************************************************************/ void memory_remove(void *malloc_mem_ptr); /****************************************************************//** * \brief * Removes the entry for a named entry from the database. (This does * not delete the memory). * * Typical Usage * * my_mem->memory_delete("Density"); *******************************************************************/ void memory_remove(const char *name); /****************************************************************//** * \brief * Gets initial memory pointer from database for iterating over the * entries and processing each. * * Typical Usage * * for (void *mem_ptr = my_mem.memory_begin(); mem_ptr!=NULL; * mem_ptr = my_mem.memory_next() ){ * ... process entries ... * } *******************************************************************/ void *memory_begin(void); /****************************************************************//** * \brief * Gets next memory pointer from database for iterating over the * entries and processing each. Note that their is an implied caching * of the current memory pointer in MallocPlus. * * Typical Usage * * for (void *mem_ptr = my_mem.memory_begin(); mem_ptr!=NULL; * mem_ptr = my_mem.memory_next() ){ * ... process entries ... * } *******************************************************************/ void *memory_next(void); /****************************************************************//** * \brief * Gets initial memory pointer from database for iterating over the * entries and processing each. * * Typical Usage * * for (void *mem_ptr = my_mem.memory_by_name_begin(); mem_ptr!=NULL; * mem_ptr = my_mem.memory_by_name_next() ){ * ... process entries ... * } *******************************************************************/ void *memory_by_name_begin(void); /****************************************************************//** * \brief * Gets next memory pointer from database for iterating over the * entries and processing each. Note that their is an implied caching * of the current memory pointer in MallocPlus. * * Typical Usage * * for (void *mem_ptr = my_mem.memory_by_name_begin(); mem_ptr!=NULL; * mem_ptr = my_mem.memory_by_name_next() ){ * ... process entries ... * } *******************************************************************/ void *memory_by_name_next(void); /****************************************************************//** * \brief * Gets initial memory entry from database for iterating over the * entries and processing each. * * Typical Usage * * malloc_plus_memory_entry memory_item; * for (memory_item = my_mem.memory_entry_begin(); * memory_item != my_mem.memory_entry_end(); * memory_item = my_mem.memory_entry_next() ){ * ... process entries ... * } *******************************************************************/ malloc_plus_memory_entry *memory_entry_begin(void); /****************************************************************//** * \brief * Gets next memory entry from database for iterating over the * entries and processing each. * * Typical Usage * * malloc_plus_memory_entry memory_item; * for (memory_item = my_mem.memory_entry_begin(); * memory_item != my_mem.memory_entry_end(); * memory_item = my_mem.memory_entry_next() ){ * ... process entries ... * } *******************************************************************/ malloc_plus_memory_entry *memory_entry_next(void); /****************************************************************//** * \brief * Gets initial memory iterator from database for iterating over the * entries and processing each. * * Typical Usage * * malloc_plus_memory_entry *memory_item; * for (memory_item = my_mem.memory_entry_begin(); * memory_item != my_mem.memory_entry_end(); * memory_item = my_mem.memory_entry_next() ){ * ... process entries ... * } *******************************************************************/ malloc_plus_memory_entry *memory_entry_end(void); /****************************************************************//** * \brief * Gets initial memory entry from name database for iterating over the * entries and processing each. * * Typical Usage * * malloc_plus_memory_entry memory_item; * for (memory_item = my_mem.memory_entry_by_name_begin(); * memory_item != my_mem.memory_entry_by_name_end(); * memory_item = my_mem.memory_entry_by_name_next() ){ * ... process entries ... * } *******************************************************************/ malloc_plus_memory_entry *memory_entry_by_name_begin(void); /****************************************************************//** * \brief * Gets next memory entry from database for iterating over the * entries and processing each. * * Typical Usage * * malloc_plus_memory_entry memory_item; * for (memory_item = my_mem.memory_entry_by_name_begin(); * memory_item != my_mem.memory_entry_by_name_end(); * memory_item = my_mem.memory_entry_by_name_next() ){ * ... process entries ... * } *******************************************************************/ malloc_plus_memory_entry *memory_entry_by_name_next(void); /****************************************************************//** * \brief * Gets initial memory iterator from database for iterating over the * entries and processing each. * * Typical Usage * * malloc_plus_memory_entry *memory_item; * for (memory_item = my_mem.memory_entry_by_name_begin(); * memory_item != my_mem.memory_entry_by_name_end(); * memory_item = my_mem.memory_entry_by_name_next() ){ * ... process entries ... * } *******************************************************************/ malloc_plus_memory_entry *memory_entry_by_name_end(void); /****************************************************************//** * \brief * Get number of elements for a memory pointer in the database. * * **Parameters** * * void *malloc_mem_ptr -- memory pointer for entry in the database * * Typical Usage * * size_t nsize = my_mem->get_memory_size(density); *******************************************************************/ size_t get_memory_size(void *malloc_mem_ptr); /****************************************************************//** * \brief * Get the memory capacity in number of elements for a memory pointer * in the database. Memory capacity is the overallocated size of the * array in schemes where memory is managed internally to reduce * the number of reallocations. * * **Parameters** * * void *malloc_mem_ptr -- memory pointer for entry in the database * * Typical Usage * * size_t var_capacity = my_mem->get_memory_capacity(density); *******************************************************************/ size_t get_memory_capacity(void *malloc_mem_ptr); /****************************************************************//** * \brief * Get the element size for a memory pointer in the database. * * **Parameters** * * void *malloc_mem_ptr -- memory pointer for entry in the database * * Typical Usage * * int elsize = my_mem->get_memory_elemsize(density); *******************************************************************/ int get_memory_elemsize(void *malloc_mem_ptr); /****************************************************************//** * \brief * Get name for a memory pointer in the database. * * **Parameters** * * void *malloc_mem_ptr -- memory pointer for entry in the database * * Typical Usage * * const char *var_name = my_mem->get_memory_name(density); *******************************************************************/ const char *get_memory_name(void *malloc_mem_ptr); /****************************************************************//** * \brief * Get memory pointer for a named entry from the database. * * **Parameters** * * const char *name -- name of entry in the database * * Typical Usage * * density = my_mem->get_memory_ptr("Density"); *******************************************************************/ void *get_memory_ptr(const char *name); /****************************************************************//** * \brief * Set a memory attribute for a memory pointer in the database. * * **Parameters** * * void *malloc_mem_ptr -- memory pointer of entry in the database * * int attribute -- flag to set for entry * * Typical Usage * * my_mem->set_memory_attribute(density, HOST_MANAGED_MEMORY); *******************************************************************/ void set_memory_attribute(void *malloc_mem_ptr, int attribute); /****************************************************************//** * \brief * Clear memory attribute for a memory pointer in the database. * * **Parameters** * * void *malloc_mem_ptr -- memory pointer of entry in the database * * int attribute -- flag to clear for entry * * Typical Usage * * my_mem->clear_memory_attribute(density, HOST_MANAGED_MEMORY); *******************************************************************/ void clear_memory_attribute(void *malloc_mem_ptr, int attribute); /****************************************************************//** * \brief * Get memory attributes for a memory pointer in the database. Returns * the flag field. * * **Parameters** * * void *malloc_mem_ptr -- memory pointer of entry in the database * * Typical Usage * * int flag = my_mem->get_memory_attribute(density); *******************************************************************/ int get_memory_flags(void *malloc_mem_ptr); /****************************************************************//** * \brief * Checks the setting for a memory attribute for a memory pointer in * the database. Returns true for set and false for unset. * * **Parameters** * * void *malloc_mem_ptr -- memory pointer of entry in the database * * int attribute -- flag to check setting for entry * * Typical Usage * * bool flag = my_mem->check_memory_attribute(density, HOST_MANAGED_MEMORY); *******************************************************************/ bool check_memory_attribute(void *malloc_mem_ptr, int attribute); }; extern "C" { MallocPlus *MallocPlus_new(); void MallocPlus_memory_report(MallocPlus *mem_object); void MallocPlus_memory_add(MallocPlus *mem_object, void *dbleptr, size_t nelem, size_t elsize, char *name, unsigned long long flags); void MallocPlus_memory_add_nD(MallocPlus *mem_object, void *dbleptr, int ndim, size_t *nelem, size_t elsize, char *name, unsigned long long flags); } #endif // ifndef MALLOCPLUS_H_