| /* |
| * 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 <map> |
| #include <string> |
| #include <string.h> |
| |
| #ifdef HAVE_CONFIG_H |
| #include <config.h> |
| #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<string, malloc_plus_memory_entry*> memory_name_dict; //!< Dictionary entries by name |
| map<void*, malloc_plus_memory_entry*> 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_ |
| |