| /* |
| * Copyright (c) 2011-2014, 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 |
| * Neal Davis davis68@lanl.gov, davis68@illinois.edu |
| * David Nicholaeff dnic@lanl.gov, mtrxknight@aol.com |
| * Dennis Trujillo dptrujillo@lanl.gov, dptru10@gmail.com |
| * |
| */ |
| |
| // SKG TODO op realloc (similar to managed) |
| |
| #undef HAVE_OPENCL |
| |
| #include "MallocPlus.h" |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <stdio.h> |
| #include <algorithm> |
| #include <queue> |
| #include <string.h> |
| #ifdef HAVE_OPENCL |
| #include "ezcl/ezcl.h" |
| #endif |
| |
| #ifndef DEBUG |
| #define DEBUG 0 |
| #endif |
| #define WARNING_SUPPRESSION 0 |
| |
| #ifdef HAVE_CL_DOUBLE |
| #ifdef HAVE_OPENCL |
| typedef cl_double2 cl_real2; |
| #endif |
| #else |
| #ifdef HAVE_OPENCL |
| typedef cl_float2 cl_real2; |
| #endif |
| #endif |
| |
| #ifndef MIN |
| #define MIN(a,b) ((a) < (b) ? (a) : (b)) |
| #endif |
| |
| #ifndef SWAP_PTR |
| #define SWAP_PTR(xnew,xold,xtmp) (xtmp=xnew, xnew=xold, xold=xtmp) |
| #endif |
| |
| typedef unsigned int uint; |
| map<void *,malloc_plus_memory_entry*>::iterator it_save, it_end; |
| map<string, malloc_plus_memory_entry*, cmp_str>::iterator it_save_by_name, it_end_by_name; |
| |
| #if defined(HAVE_MPI) |
| void |
| MallocPlus::pinit(MPI_Comm smComm, std::size_t memPoolSize) |
| { |
| #if defined(HAVE_J7) |
| try { |
| j7 = new J7(smComm, memPoolSize); |
| } |
| catch(...) { |
| std::cerr << "*** pinit failure ***" << std::endl; |
| throw; |
| } |
| #else |
| // Just to suppress compiler warnings |
| if (WARNING_SUPPRESSION) printf("DEBUG memPoolSize = %lu smComm = %p\n",memPoolSize,smComm); |
| #endif |
| } |
| |
| void |
| MallocPlus::pfini(void) |
| { |
| #if defined(HAVE_J7) |
| try { |
| delete j7; |
| j7 = NULL; |
| } |
| catch(...) { |
| std::cerr << "*** pfini failure ***" << std::endl; |
| throw; |
| } |
| #endif |
| } |
| #endif // if defined(HAVE_MPI) |
| |
| void *MallocPlus::memory_malloc(size_t nelem, size_t elsize, const char *name, int flags){ |
| malloc_plus_memory_entry *memory_item = (malloc_plus_memory_entry *)malloc(sizeof(malloc_plus_memory_entry)); |
| |
| memory_item->mem_nelem = (size_t *)malloc(1*sizeof(size_t)); |
| memory_item->mem_nelem[0] = nelem; |
| memory_item->mem_ndims = 1; |
| memory_item->mem_elsize = elsize; |
| memory_item->mem_flags = flags; |
| |
| // allocate memory on the accelerator if flag is set |
| if ((flags & DEVICE_REGULAR_MEMORY) != 0){ |
| #ifdef HAVE_OPENCL |
| cl_context context = ezcl_get_context(); |
| memory_item->mem_capacity = nelem; |
| memory_item->mem_ptr = ezcl_device_memory_malloc(context, NULL, name, nelem, elsize, CL_MEM_READ_WRITE, 0); |
| #endif |
| } |
| // Managed memory allocates extra space and expands as necessary to reduce allocations |
| else if ((flags & HOST_MANAGED_MEMORY) != 0){ |
| memory_item->mem_capacity = 2 * nelem; |
| memory_item->mem_ptr = malloc(2* nelem*elsize); |
| } |
| #ifdef HAVE_J7 |
| // experimental shared memory allocation |
| else if (flags & LOAD_BALANCE_MEMORY) { |
| memory_item->mem_capacity = nelem; |
| memory_item->mem_ptr = j7->memAlloc(nelem * elsize); |
| } |
| #endif |
| // Just regular memory allocation |
| else { |
| memory_item->mem_capacity = nelem; |
| memory_item->mem_ptr = malloc(nelem*elsize); |
| } |
| |
| memory_item->mem_name = strdup(name); // Mallocs memory for copy |
| |
| //printf("MALLOC_PLUS_MEMORY_MALLOC: DEBUG -- malloc plus memory pointer for :%s: is %p nelements %ld elsize is %ld flags %d\n",memory_item->mem_name,memory_item->mem_ptr,memory_item->mem_nelem[0],memory_item->mem_elsize,memory_item->mem_flags); |
| |
| // Insert entry into dictionary -- two versions, one by name and another by pointer address |
| memory_name_dict.insert(std::pair<string, malloc_plus_memory_entry*>(name, memory_item) ); |
| memory_ptr_dict.insert(std::pair<void*, malloc_plus_memory_entry*>(memory_item->mem_ptr, memory_item) ); |
| |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_MALLOC: DEBUG -- malloc plus memory pointer for :%s: is %p nelements %ld elsize is %ld\n",memory_item->mem_name,memory_item->mem_ptr,memory_item->mem_nelem[0],memory_item->mem_elsize); |
| |
| // return the pointer for use by the calling routine |
| return(memory_item->mem_ptr); |
| } |
| |
| void *MallocPlus::memory_realloc(size_t nelem, void *malloc_mem_ptr){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| void *mem_ptr=NULL; |
| |
| if (it != memory_ptr_dict.end() ){ |
| // "second" will be the pointer to the memory entry data structure -- the value |
| // associated with the key |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_REALLOC: DEBUG -- reallocated memory pointer %p\n",memory_item->mem_ptr); |
| |
| // memory pointer will probably change, so delete the dictionary entry |
| // named dictionary entry does not need to change; the pointer in the data structure |
| // will just be updated, but the pointer to the memory entry data structure |
| // will be the same |
| memory_ptr_dict.erase(it); |
| |
| if (memory_item->mem_flags & HOST_MANAGED_MEMORY){ |
| // Check to see if memory needs to be expanded |
| if (nelem > memory_item->mem_capacity) { |
| // Need to realloc memory. Allocate extra for growth of array. |
| mem_ptr=realloc(memory_item->mem_ptr, 2*nelem*memory_item->mem_elsize); |
| memory_item->mem_capacity = 2*nelem; |
| memory_item->mem_nelem[0] = nelem; |
| memory_item->mem_ptr = mem_ptr; |
| } else { |
| // Just move size to use more of memory buffer |
| memory_item->mem_nelem[0] = nelem; |
| } |
| } |
| #ifdef HAVE_J7 |
| else if (memory_item->mem_flags & LOAD_BALANCE_MEMORY) { |
| mem_ptr = j7->memRealloc(memory_item->mem_ptr, nelem * memory_item->mem_elsize); |
| memory_item->mem_capacity = nelem; |
| memory_item->mem_nelem[0] = nelem; |
| memory_item->mem_ptr = mem_ptr; |
| } |
| #endif |
| else { |
| mem_ptr=realloc(memory_item->mem_ptr, nelem*memory_item->mem_elsize); |
| memory_item->mem_capacity = nelem; |
| memory_item->mem_nelem[0] = nelem; |
| memory_item->mem_ptr = mem_ptr; |
| } |
| |
| // Put the pointer entry back into the dictionary |
| memory_ptr_dict.insert(std::pair<void*, malloc_plus_memory_entry*>(memory_item->mem_ptr, memory_item) ); |
| } else { |
| if (DEBUG) printf("Warning -- memory pointer %p not found\n",malloc_mem_ptr); |
| } |
| |
| return(mem_ptr); |
| } |
| |
| void *MallocPlus::memory_realloc(size_t nelem, const char *name){ |
| map <string, malloc_plus_memory_entry*>::iterator it = memory_name_dict.find(name); |
| void *mem_ptr=NULL; |
| |
| if (it != memory_name_dict.end() ){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_REALLOC: DEBUG -- " |
| "reallocated memory pointer %p\n",memory_item->mem_ptr); |
| |
| // Need to get the iterator for the pointer entry; the one above is for the name entry |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(memory_item->mem_ptr); |
| memory_ptr_dict.erase(it); |
| |
| if (memory_item->mem_flags & HOST_MANAGED_MEMORY) { |
| // Check to see if memory needs to be expanded |
| if (nelem > memory_item->mem_capacity) { |
| // Need to realloc memory. Allocate extra for growth of array. |
| mem_ptr=realloc(memory_item->mem_ptr, 2*nelem*memory_item->mem_elsize); |
| memory_item->mem_capacity = 2*nelem; |
| memory_item->mem_nelem[0] = nelem; |
| memory_item->mem_ptr = mem_ptr; |
| } else { |
| // Just move size to use more of memory buffer |
| memory_item->mem_nelem[0] = nelem; |
| } |
| } |
| #ifdef HAVE_J7 |
| else if (memory_item->mem_flags & LOAD_BALANCE_MEMORY) { |
| mem_ptr = j7->memRealloc(memory_item->mem_ptr, nelem * memory_item->mem_elsize); |
| memory_item->mem_capacity = nelem; |
| memory_item->mem_nelem[0] = nelem; |
| memory_item->mem_ptr = mem_ptr; |
| } |
| #endif |
| else { |
| //memory_name_dict.erase(it); |
| mem_ptr=realloc(memory_item->mem_ptr, nelem*memory_item->mem_elsize); |
| memory_item->mem_capacity = nelem; |
| memory_item->mem_nelem[0] = nelem; |
| memory_item->mem_ptr = mem_ptr; |
| //memory_name_dict.insert(std::pair<string, malloc_plus_memory_entry*>(name, memory_item) ); |
| } |
| |
| memory_ptr_dict.insert(std::pair<void*, malloc_plus_memory_entry*>(memory_item->mem_ptr, memory_item) ); |
| } else { |
| if (DEBUG) printf("Warning -- memory named %s not found\n",name); |
| } |
| |
| return(mem_ptr); |
| } |
| |
| void *MallocPlus::memory_request(size_t new_capacity, void *malloc_mem_ptr){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| void *mem_ptr=NULL; |
| |
| if (it != memory_ptr_dict.end() ){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_REQUEST: DEBUG -- reallocated memory pointer %p\n",memory_item->mem_ptr); |
| memory_ptr_dict.erase(it); |
| mem_ptr=realloc(memory_item->mem_ptr, new_capacity*memory_item->mem_elsize); |
| memory_item->mem_capacity = new_capacity; |
| memory_item->mem_ptr = mem_ptr; |
| memory_ptr_dict.insert(std::pair<void*, malloc_plus_memory_entry*>(mem_ptr, memory_item) ); |
| } else { |
| if (DEBUG) printf("Warning -- memory pointer %p not found\n",malloc_mem_ptr); |
| } |
| |
| return(mem_ptr); |
| } |
| |
| // Increases the capacity of the allocated memory, primarily for the managed memory functionality |
| void *MallocPlus::memory_request(size_t new_capacity, const char *name){ |
| map <string, malloc_plus_memory_entry*>::iterator it = memory_name_dict.find(name); |
| void *mem_ptr=NULL; |
| |
| if (it != memory_name_dict.end() ){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_REQUEST: DEBUG -- reallocated memory pointer %p\n",memory_item->mem_ptr); |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(memory_item->mem_ptr); |
| memory_ptr_dict.erase(it); |
| mem_ptr=realloc(memory_item->mem_ptr, new_capacity*memory_item->mem_elsize); |
| memory_item->mem_capacity = new_capacity; |
| memory_item->mem_ptr = mem_ptr; |
| memory_ptr_dict.insert(std::pair<void*, malloc_plus_memory_entry*>(mem_ptr, memory_item) ); |
| } else { |
| if (DEBUG) printf("Warning -- memory named %s not found\n",name); |
| } |
| |
| return(mem_ptr); |
| } |
| |
| void MallocPlus::memory_realloc_all(size_t nelem){ |
| // Need a copy of the dictionary since we will be modifying while being used |
| map <void *, malloc_plus_memory_entry*> memory_ptr_dict_old = memory_ptr_dict; |
| |
| // Need iterators to both new and old; new will be modified during the loop |
| map<void *, malloc_plus_memory_entry*>::iterator it_old; |
| map<void *, malloc_plus_memory_entry*>::iterator it_new; |
| void *mem_ptr=NULL; |
| |
| for ( it_old=memory_ptr_dict_old.begin(); it_old != memory_ptr_dict_old.end(); it_old++){ |
| // Get the memory entry for the old dictionary |
| malloc_plus_memory_entry *memory_item = it_old->second; |
| |
| // Get the iterator to the new dictionary by memory pointer and delete it |
| // since it will probably change |
| // The dictionary by name does not need to be updated |
| it_new = memory_ptr_dict.find(memory_item->mem_ptr); |
| memory_ptr_dict.erase(it_new); |
| |
| if (memory_item->mem_flags & HOST_MANAGED_MEMORY) { |
| if (nelem > memory_item->mem_capacity) { |
| mem_ptr=realloc(memory_item->mem_ptr, nelem*memory_item->mem_elsize); |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_REALLOC_ALL: DEBUG -- reallocated memory pointer %p new pointer %p\n",memory_item->mem_ptr,mem_ptr); |
| memory_item->mem_capacity = nelem; |
| memory_item->mem_nelem[0] = nelem; |
| memory_item->mem_ptr = mem_ptr; |
| } else { |
| memory_item->mem_nelem[0] = nelem; |
| } |
| } |
| #ifdef HAVE_J7 |
| else if (it->mem_flags & LOAD_BALANCE_MEMORY) { |
| mem_ptr = j7->memRealloc(memory_item->mem_ptr, nelem * memory_item->mem_elsize); |
| memory_item->mem_capacity = nelem; |
| memory_item->mem_nelem[0] = nelem; |
| memory_item->mem_ptr = mem_ptr; |
| } |
| #endif |
| else { |
| mem_ptr=realloc(memory_item->mem_ptr, nelem*memory_item->mem_elsize); |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_REALLOC_ALL: DEBUG -- reallocated memory pointer %p new pointer %p\n",memory_item->mem_ptr,mem_ptr); |
| memory_item->mem_capacity = nelem; |
| memory_item->mem_nelem[0] = nelem; |
| memory_item->mem_ptr = mem_ptr; |
| } |
| |
| //Insert the entry back into the dictionary |
| memory_ptr_dict.insert(std::pair<void*, malloc_plus_memory_entry*>(mem_ptr, memory_item) ); |
| } |
| } |
| |
| void MallocPlus::memory_request_all(size_t new_capacity){ |
| map <void *, malloc_plus_memory_entry*> memory_ptr_dict_old = memory_ptr_dict; |
| |
| map<void *, malloc_plus_memory_entry*>::iterator it_old; |
| map<void *, malloc_plus_memory_entry*>::iterator it_new; |
| |
| for ( it_old=memory_ptr_dict_old.begin(); it_old != memory_ptr_dict_old.end(); it_old++){ |
| malloc_plus_memory_entry *memory_item = it_old->second; |
| |
| it_new = memory_ptr_dict.find(memory_item->mem_ptr); |
| memory_ptr_dict.erase(it_new); |
| |
| void *mem_ptr=realloc(memory_item->mem_ptr, new_capacity*memory_item->mem_elsize); |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_REQUEST_ALL: DEBUG -- reallocated memory pointer %p new pointer %p\n",memory_item->mem_ptr,mem_ptr); |
| memory_item->mem_capacity = new_capacity; |
| memory_item->mem_ptr = mem_ptr; |
| |
| memory_ptr_dict.insert(std::pair<void*, malloc_plus_memory_entry*>(mem_ptr, memory_item) ); |
| } |
| } |
| |
| // This routine is for memory allocated by the host program and added to the database |
| void *MallocPlus::memory_add(void *malloc_mem_ptr, size_t nelem, size_t elsize, const char *name, int flags){ |
| malloc_plus_memory_entry *memory_item = (malloc_plus_memory_entry *)malloc(sizeof(malloc_plus_memory_entry)); |
| |
| memory_item->mem_nelem = (size_t *)malloc(1*sizeof(size_t)); |
| memory_item->mem_nelem[0] = nelem; |
| memory_item->mem_ndims = 1; |
| memory_item->mem_capacity = nelem; |
| memory_item->mem_elsize = elsize; |
| memory_item->mem_flags = flags; |
| memory_item->mem_ptr = malloc_mem_ptr; |
| memory_item->mem_name = strdup(name); // mallocs memory |
| memory_ptr_dict.insert(std::pair<void *, malloc_plus_memory_entry*>(malloc_mem_ptr, memory_item) ); |
| memory_name_dict.insert(std::pair<string, malloc_plus_memory_entry*>(name, memory_item) ); |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_ADD: DEBUG -- added memory pointer for %s is %p\n",name,malloc_mem_ptr); |
| |
| return(malloc_mem_ptr); |
| } |
| |
| // This routine is for memory allocated by the host program and added to the database |
| void *MallocPlus::memory_add(void *malloc_mem_ptr, int ndim, size_t *nelem, size_t elsize, const char *name, int flags){ |
| malloc_plus_memory_entry *memory_item = (malloc_plus_memory_entry *)malloc(sizeof(malloc_plus_memory_entry)); |
| |
| memory_item->mem_nelem = (size_t *)malloc(ndim*sizeof(size_t)); |
| for (int i=0; i<ndim; i++){ |
| memory_item->mem_nelem[i] = nelem[i]; |
| } |
| memory_item->mem_ndims = ndim; |
| memory_item->mem_capacity = 0; |
| memory_item->mem_elsize = elsize; |
| memory_item->mem_flags = flags; |
| memory_item->mem_ptr = malloc_mem_ptr; |
| memory_item->mem_name = strdup(name); // mallocs memory |
| memory_ptr_dict.insert(std::pair<void *, malloc_plus_memory_entry*>(malloc_mem_ptr, memory_item) ); |
| memory_name_dict.insert(std::pair<string, malloc_plus_memory_entry*>(name, memory_item) ); |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_ADD: DEBUG -- added memory pointer for %s is %p\n",name,malloc_mem_ptr); |
| |
| return(malloc_mem_ptr); |
| } |
| |
| double *MallocPlus::memory_reorder(double *malloc_mem_ptr, int *iorder){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| |
| if (it != memory_ptr_dict.end() ){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| double *ptr; |
| |
| memory_ptr_dict.erase(it); |
| |
| if (DEBUG) printf("Found memory item ptr %p name %s\n",memory_item->mem_ptr,memory_item->mem_name); |
| double *tmp = (double *)malloc(memory_item->mem_nelem[0]*memory_item->mem_elsize); |
| #ifdef _OPENMP |
| #pragma omp parallel for |
| #endif |
| for (uint ic = 0; ic < memory_item->mem_nelem[0]; ic++){ |
| tmp[ic] = malloc_mem_ptr[iorder[ic]]; |
| } |
| SWAP_PTR(malloc_mem_ptr, tmp, ptr); |
| free(tmp); |
| memory_item->mem_ptr = malloc_mem_ptr; |
| |
| memory_ptr_dict.insert(std::pair<void *, malloc_plus_memory_entry*>(malloc_mem_ptr, memory_item) ); |
| } else { |
| if (DEBUG) printf("Warning -- memory pointer %p not found\n",malloc_mem_ptr); |
| } |
| |
| return(malloc_mem_ptr); |
| } |
| |
| float *MallocPlus::memory_reorder(float *malloc_mem_ptr, int *iorder){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| |
| if (it != memory_ptr_dict.end() ){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| float *ptr; |
| |
| memory_ptr_dict.erase(it); |
| |
| if (DEBUG) printf("Found memory item ptr %p name %s\n",memory_item->mem_ptr,memory_item->mem_name); |
| float *tmp = (float *)malloc(memory_item->mem_nelem[0]*memory_item->mem_elsize); |
| #ifdef _OPENMP |
| #pragma omp parallel for |
| #endif |
| for (uint ic = 0; ic < memory_item->mem_nelem[0]; ic++){ |
| tmp[ic] = malloc_mem_ptr[iorder[ic]]; |
| } |
| SWAP_PTR(malloc_mem_ptr, tmp, ptr); |
| free(tmp); |
| memory_item->mem_ptr = malloc_mem_ptr; |
| |
| memory_ptr_dict.insert(std::pair<void*, malloc_plus_memory_entry*>(malloc_mem_ptr, memory_item) ); |
| } else { |
| if (DEBUG) printf("Warning -- memory pointer %p not found\n",malloc_mem_ptr); |
| } |
| |
| return(malloc_mem_ptr); |
| } |
| |
| int *MallocPlus::memory_reorder(int *malloc_mem_ptr, int *iorder){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| |
| if (it != memory_ptr_dict.end() ){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| int *ptr; |
| |
| memory_ptr_dict.erase(it); |
| |
| if (DEBUG) printf("Found memory item ptr %p name %s\n",memory_item->mem_ptr,memory_item->mem_name); |
| int *tmp = (int *)malloc(memory_item->mem_nelem[0]*memory_item->mem_elsize); |
| #ifdef _OPENMP |
| #pragma omp parallel for |
| #endif |
| for (uint ic = 0; ic < memory_item->mem_nelem[0]; ic++){ |
| tmp[ic] = malloc_mem_ptr[iorder[ic]]; |
| } |
| SWAP_PTR(malloc_mem_ptr, tmp, ptr); |
| free(tmp); |
| memory_item->mem_ptr = malloc_mem_ptr; |
| |
| memory_ptr_dict.insert(std::pair<void*, malloc_plus_memory_entry*>(malloc_mem_ptr, memory_item) ); |
| } else { |
| if (DEBUG) printf("Warning -- memory pointer %p not found\n",malloc_mem_ptr); |
| } |
| |
| return(malloc_mem_ptr); |
| } |
| |
| int *MallocPlus::memory_reorder_indexarray(int *malloc_mem_ptr, int *iorder, int *inv_iorder){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| |
| if (it != memory_ptr_dict.end() ){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| int *ptr; |
| |
| if (DEBUG) printf("Found memory_item ptr %p name %s\n",memory_item->mem_ptr,memory_item->mem_name); |
| memory_ptr_dict.erase(it); |
| int *tmp = (int *)malloc(memory_item->mem_nelem[0]*memory_item->mem_elsize); |
| for (uint ic = 0; ic < memory_item->mem_nelem[0]; ic++){ |
| tmp[ic] = inv_iorder[malloc_mem_ptr[iorder[ic]]]; |
| } |
| SWAP_PTR(malloc_mem_ptr, tmp, ptr); |
| free(tmp); |
| memory_item->mem_ptr = malloc_mem_ptr; |
| memory_ptr_dict.insert(std::pair<void*, malloc_plus_memory_entry*>(malloc_mem_ptr, memory_item) ); |
| } else { |
| if (DEBUG) printf("Warning -- memory pointer %p not found\n",malloc_mem_ptr); |
| } |
| |
| return(malloc_mem_ptr); |
| } |
| |
| void MallocPlus::memory_reorder_all(int *iorder){ |
| map <void *, malloc_plus_memory_entry*> memory_ptr_dict_old = memory_ptr_dict; |
| map <void *, malloc_plus_memory_entry*>::iterator it_old; |
| vector<int> inv_iorder; |
| |
| for ( it_old=memory_ptr_dict_old.begin(); it_old != memory_ptr_dict_old.end(); it_old++){ |
| malloc_plus_memory_entry *memory_item_old = it_old->second; |
| |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(memory_item_old->mem_ptr); |
| malloc_plus_memory_entry *memory_item = it_old->second; |
| memory_ptr_dict.erase(it); |
| |
| if (memory_item_old->mem_flags & 0x100) { |
| if (inv_iorder.size() < memory_item_old->mem_nelem[0]) { |
| inv_iorder.resize(memory_item_old->mem_nelem[0]); |
| for (int ic = 0; ic < (int)memory_item_old->mem_nelem[0]; ic++){ |
| inv_iorder[iorder[ic]] = ic; |
| } |
| } |
| int *ptr; |
| int *malloc_mem_ptr = (int *)memory_item_old->mem_ptr; |
| int *tmp = (int *)malloc(memory_item_old->mem_nelem[0]*memory_item_old->mem_elsize); |
| for (uint ic = 0; ic < memory_item_old->mem_nelem[0]; ic++){ |
| tmp[ic] = inv_iorder[malloc_mem_ptr[iorder[ic]]]; |
| } |
| memory_replace(malloc_mem_ptr, tmp); |
| SWAP_PTR(malloc_mem_ptr, tmp, ptr); |
| free(tmp); |
| memory_item->mem_ptr = malloc_mem_ptr; |
| memory_ptr_dict.insert(std::pair<void*, malloc_plus_memory_entry*>(malloc_mem_ptr, memory_item) ); |
| } else if (memory_item_old->mem_elsize == 8){ |
| double *ptr; |
| double *malloc_mem_ptr = (double *)memory_item_old->mem_ptr; |
| double *tmp = (double *)malloc(memory_item_old->mem_nelem[0]*memory_item_old->mem_elsize); |
| |
| for (uint ic = 0; ic < memory_item_old->mem_nelem[0]; ic++){ |
| tmp[ic] = malloc_mem_ptr[iorder[ic]]; |
| } |
| |
| SWAP_PTR(malloc_mem_ptr, tmp, ptr); |
| free(tmp); |
| memory_item->mem_ptr = malloc_mem_ptr; |
| memory_ptr_dict.insert(std::pair<void*, malloc_plus_memory_entry*>(malloc_mem_ptr, memory_item) ); |
| } else { |
| float *ptr; |
| float *malloc_mem_ptr = (float *)memory_item_old->mem_ptr; |
| float *tmp = (float *)malloc(memory_item_old->mem_nelem[0]*memory_item_old->mem_elsize); |
| for (uint ic = 0; ic < memory_item_old->mem_nelem[0]; ic++){ |
| tmp[ic] = malloc_mem_ptr[iorder[ic]]; |
| } |
| memory_replace(malloc_mem_ptr, tmp); |
| SWAP_PTR(malloc_mem_ptr, tmp, ptr); |
| free(tmp); |
| memory_item->mem_ptr = malloc_mem_ptr; |
| memory_ptr_dict.insert(std::pair<void*, malloc_plus_memory_entry*>(malloc_mem_ptr, memory_item) ); |
| } |
| |
| } |
| |
| inv_iorder.clear(); |
| } |
| |
| void MallocPlus::memory_report(void){ |
| map<void *, malloc_plus_memory_entry*>::iterator it_ptr; |
| |
| for ( it_ptr=memory_ptr_dict.begin(); it_ptr != memory_ptr_dict.end(); it_ptr++){ |
| malloc_plus_memory_entry *memory_item = it_ptr->second; |
| |
| printf("MallocPlus ptr %p: name %10s ptr %p dims %lu nelem (", |
| it_ptr->first,memory_item->mem_name,memory_item->mem_ptr,memory_item->mem_ndims); |
| |
| char nelemstring[80]; |
| char *str_ptr = nelemstring; |
| str_ptr += sprintf(str_ptr,"%lu", memory_item->mem_nelem[0]); |
| for (uint i = 1; i < memory_item->mem_ndims; i++){ |
| str_ptr += sprintf(str_ptr,", %lu", memory_item->mem_nelem[i]); |
| } |
| printf("%12s",nelemstring); |
| |
| printf(") elsize %lu flags %d capacity %lu\n", |
| memory_item->mem_elsize,memory_item->mem_flags,memory_item->mem_capacity); |
| } |
| |
| map<string, malloc_plus_memory_entry*>::iterator it_name; |
| |
| for ( it_name=memory_name_dict.begin(); it_name != memory_name_dict.end(); it_name++){ |
| malloc_plus_memory_entry *memory_item = it_name->second; |
| |
| printf("MallocPlus name %14s: name %10s ptr %p dims %lu nelem (", |
| it_name->first.c_str(),memory_item->mem_name,memory_item->mem_ptr,memory_item->mem_ndims); |
| |
| char nelemstring[80]; |
| char *str_ptr = nelemstring; |
| str_ptr += sprintf(str_ptr,"%lu", memory_item->mem_nelem[0]); |
| for (uint i = 1; i < memory_item->mem_ndims; i++){ |
| str_ptr += sprintf(str_ptr,", %lu", memory_item->mem_nelem[i]); |
| } |
| printf("%12s",nelemstring); |
| |
| printf(") elsize %lu flags %d capacity %lu\n", |
| memory_item->mem_elsize,memory_item->mem_flags,memory_item->mem_capacity); |
| } |
| } |
| |
| void *MallocPlus::memory_delete(void *malloc_mem_ptr){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| |
| if (it != memory_ptr_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_REMOVE: DEBUG -- removed memory pointer %p\n",memory_item->mem_ptr); |
| |
| if ((memory_item->mem_flags & DEVICE_REGULAR_MEMORY) != 0){ |
| #ifdef HAVE_OPENCL |
| //printf("MALLOC_PLUS_MEMORY_REMOVE: DEBUG -- removed memory pointer %p\n",memory_item->mem_ptr); |
| ezcl_device_memory_delete(memory_item->mem_ptr); |
| #endif |
| } |
| #ifdef HAVE_J7 |
| else if (memory_item->mem_flags & LOAD_BALANCE_MEMORY) { |
| j7->memFree(memory_item->mem_ptr); |
| } |
| #endif |
| else { |
| free(memory_item->mem_ptr); |
| } |
| |
| memory_ptr_dict.erase(it); |
| // Need to delete the entry in the name dictionary. This is done in a separate scope |
| // so the iterator "it" is isolated for this use |
| { |
| map <string, malloc_plus_memory_entry*>::iterator it = memory_name_dict.find(memory_item->mem_name); |
| memory_name_dict.erase(it); |
| } |
| |
| free(memory_item->mem_nelem); |
| free(memory_item->mem_name); |
| free(memory_item); |
| } else { |
| if (DEBUG) printf("Warning -- memory pointer %p not found\n",malloc_mem_ptr); |
| } |
| |
| return(NULL); |
| } |
| |
| void *MallocPlus::memory_delete(const char *name){ |
| map <string, malloc_plus_memory_entry*>::iterator it = memory_name_dict.find(name); |
| |
| if (it != memory_name_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_REMOVE: DEBUG -- removed memory pointer %p\n",memory_item->mem_ptr); |
| if ((memory_item->mem_flags & DEVICE_REGULAR_MEMORY) != 0){ |
| #ifdef HAVE_OPENCL |
| ezcl_device_memory_delete(memory_item->mem_ptr); |
| #endif |
| } |
| #ifdef HAVE_J7 |
| else if (memory_item->mem_flags & LOAD_BALANCE_MEMORY) { |
| j7->memFree(memory_item->mem_ptr); |
| } |
| #endif |
| else { |
| free(memory_item->mem_ptr); |
| } |
| |
| memory_name_dict.erase(it); |
| { |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(memory_item->mem_ptr); |
| memory_ptr_dict.erase(it); |
| } |
| |
| free(memory_item->mem_nelem); |
| free(memory_item->mem_name); |
| free(memory_item); |
| } else { |
| if (DEBUG) printf("Warning -- memory named %s not found\n",name); |
| } |
| |
| return(NULL); |
| } |
| |
| void MallocPlus::memory_delete_all(void){ |
| map <void *, malloc_plus_memory_entry*> memory_ptr_dict_old = memory_ptr_dict; |
| map <void *, malloc_plus_memory_entry*>::iterator it; |
| |
| for ( it=memory_ptr_dict_old.begin(); it != memory_ptr_dict_old.end(); it++){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_REMOVE: DEBUG -- removed memory pointer %p name %s\n",memory_item->mem_ptr,memory_item->mem_name); |
| |
| if ((memory_item->mem_flags & DEVICE_REGULAR_MEMORY) != 0){ |
| #ifdef HAVE_OPENCL |
| ezcl_device_memory_delete(memory_item->mem_ptr); |
| #endif |
| } else { |
| free(memory_item->mem_ptr); |
| } |
| |
| free(memory_item->mem_nelem); |
| free(memory_item->mem_name); |
| free(memory_item); |
| } |
| |
| memory_ptr_dict.clear(); |
| memory_name_dict.clear(); |
| } |
| |
| // For memory that was allocated by the host and added to the database with the |
| // memory_add function. This is the corresponding routine to delete the dictionary entry. |
| // The memory itself is not freed. |
| void MallocPlus::memory_remove(void *malloc_mem_ptr){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| |
| if (it != memory_ptr_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_REMOVE: DEBUG -- removed memory pointer %p\n",memory_item->mem_ptr); |
| memory_ptr_dict.erase(it); |
| { |
| map <string, malloc_plus_memory_entry*>::iterator it = memory_name_dict.find(memory_item->mem_name); |
| memory_name_dict.erase(it); |
| } |
| free(memory_item->mem_nelem); |
| free(memory_item->mem_name); |
| free(memory_item); |
| } else { |
| if (DEBUG) printf("Warning -- memory pointer %p not found\n",malloc_mem_ptr); |
| } |
| } |
| |
| void MallocPlus::memory_remove(const char *name){ |
| map <string, malloc_plus_memory_entry*>::iterator it = memory_name_dict.find(name); |
| |
| if (it != memory_name_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("MALLOC_PLUS_MEMORY_REMOVE: DEBUG -- removed memory pointer %p\n",memory_item->mem_ptr); |
| memory_name_dict.erase(it); |
| { |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(memory_item->mem_ptr); |
| memory_ptr_dict.erase(it); |
| } |
| free(memory_item->mem_nelem); |
| free(memory_item->mem_name); |
| free(memory_item); |
| } else { |
| if (DEBUG) printf("Warning -- memory named %s not found\n",name); |
| } |
| } |
| |
| void *MallocPlus::memory_begin(void){ |
| it_save = memory_ptr_dict.begin(); |
| malloc_plus_memory_entry *memory_item = it_save->second; |
| return(memory_item->mem_ptr); |
| } |
| |
| void *MallocPlus::memory_next(void){ |
| map <void *, malloc_plus_memory_entry*>::iterator it; |
| |
| it_save++; |
| it = it_save; |
| |
| if (it != memory_ptr_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("Found memory item ptr %p name %s\n",memory_item->mem_ptr,memory_item->mem_name); |
| return(memory_item->mem_ptr); |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| return(NULL); |
| } |
| } |
| |
| void *MallocPlus::memory_by_name_begin(void){ |
| it_save_by_name = memory_name_dict.begin(); |
| malloc_plus_memory_entry *memory_item = it_save->second; |
| return(memory_item->mem_ptr); |
| } |
| |
| void *MallocPlus::memory_by_name_next(void){ |
| map<string, malloc_plus_memory_entry*, cmp_str>::iterator it_by_name; |
| |
| it_save_by_name++; |
| it_by_name = it_save_by_name; |
| |
| if (it_by_name != memory_name_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it_by_name->second; |
| |
| if (DEBUG) printf("Found memory item ptr %p name %s\n",memory_item->mem_ptr,memory_item->mem_name); |
| return(memory_item->mem_ptr); |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| return(NULL); |
| } |
| } |
| |
| malloc_plus_memory_entry* MallocPlus::memory_entry_begin(void){ |
| it_save = memory_ptr_dict.begin(); |
| malloc_plus_memory_entry *memory_item = it_save->second; |
| return(memory_item); |
| } |
| |
| malloc_plus_memory_entry* MallocPlus::memory_entry_next(void){ |
| it_save++; |
| if (it_save == memory_ptr_dict.end()) return(NULL); |
| malloc_plus_memory_entry *memory_item = it_save->second; |
| if (DEBUG) printf("Found memory item ptr %p name %s\n",memory_item->mem_ptr,memory_item->mem_name); |
| return(memory_item); |
| } |
| |
| malloc_plus_memory_entry* MallocPlus::memory_entry_end(void){ |
| return(NULL); |
| } |
| |
| malloc_plus_memory_entry* MallocPlus::memory_entry_by_name_begin(void){ |
| it_save_by_name = memory_name_dict.begin(); |
| malloc_plus_memory_entry *memory_item = it_save_by_name->second; |
| return(memory_item); |
| } |
| |
| malloc_plus_memory_entry* MallocPlus::memory_entry_by_name_next(void){ |
| it_save_by_name++; |
| if (it_save_by_name == memory_name_dict.end()) return(NULL); |
| malloc_plus_memory_entry *memory_item = it_save_by_name->second; |
| if (DEBUG) printf("Found memory item ptr %p name %s\n",memory_item->mem_ptr,memory_item->mem_name); |
| return(memory_item); |
| } |
| |
| malloc_plus_memory_entry* MallocPlus::memory_entry_by_name_end(void){ |
| return(NULL); |
| } |
| |
| size_t MallocPlus::get_memory_size(void *malloc_mem_ptr){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| |
| if (it != memory_ptr_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("Found memory item ptr %p name %s\n",memory_item->mem_ptr,memory_item->mem_name); |
| return(memory_item->mem_nelem[0]); |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| } |
| return(0); |
| } |
| |
| int MallocPlus::get_memory_elemsize(void *malloc_mem_ptr){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| |
| if (it != memory_ptr_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("Found memory item ptr %p name %s\n",memory_item->mem_ptr,memory_item->mem_name); |
| return(memory_item->mem_elsize); |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| } |
| return(0); |
| } |
| |
| int MallocPlus::get_memory_flags(void *malloc_mem_ptr){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| |
| if (it != memory_ptr_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("Found memory item ptr %p name %s attribute %d\n",memory_item->mem_ptr,memory_item->mem_name,memory_item->mem_flags); |
| return(memory_item->mem_flags); |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| } |
| return(0); |
| } |
| |
| size_t MallocPlus::get_memory_capacity(void *malloc_mem_ptr){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| |
| if (it != memory_ptr_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("Found memory item ptr %p name %s\n",memory_item->mem_ptr,memory_item->mem_name); |
| return(memory_item->mem_capacity); |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| } |
| return(0); |
| } |
| |
| const char * MallocPlus::get_memory_name(void *malloc_mem_ptr){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| |
| if (it != memory_ptr_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("Found memory item ptr %p name %s\n",memory_item->mem_ptr,memory_item->mem_name); |
| return(memory_item->mem_name); |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| } |
| return(NULL); |
| } |
| |
| void *MallocPlus::memory_replace(void *malloc_mem_ptr_old, void * const malloc_mem_ptr_new){ |
| map <void *, malloc_plus_memory_entry*>::iterator it_old = memory_ptr_dict.find(malloc_mem_ptr_old); |
| map <void *, malloc_plus_memory_entry*>::iterator it_new = memory_ptr_dict.find(malloc_mem_ptr_new); |
| |
| if (it_old != memory_ptr_dict.end() && it_new != memory_ptr_dict.end() ){ |
| malloc_plus_memory_entry *memory_item_old = it_old->second; |
| malloc_plus_memory_entry *memory_item_new = it_new->second; |
| |
| // erase the entries in the pointer dictionary |
| memory_ptr_dict.erase(it_new); |
| memory_ptr_dict.erase(it_old); |
| // get the iterators for the named dictionary |
| map <string, malloc_plus_memory_entry*>::iterator it_old = memory_name_dict.find(memory_item_old->mem_name); |
| map <string, malloc_plus_memory_entry*>::iterator it_new = memory_name_dict.find(memory_item_new->mem_name); |
| memory_name_dict.erase(it_new); |
| memory_name_dict.erase(it_old); |
| |
| if (DEBUG) printf("Found memory item ptr_old %p name %s ptr_new %p name %s\n",memory_item_old->mem_ptr,memory_item_old->mem_name,memory_item_new->mem_ptr,memory_item_new->mem_name); |
| |
| if ((memory_item_old->mem_flags & DEVICE_REGULAR_MEMORY) != 0){ |
| #ifdef HAVE_OPENCL |
| if (DEBUG) printf("Deleting device memory name %s pointer %p\n",memory_item_old->mem_name,memory_item_old->mem_ptr); |
| ezcl_device_memory_replace(&memory_item_old->mem_ptr, &memory_item_new->mem_ptr); |
| #endif |
| } |
| #ifdef HAVE_J7 |
| else if (memory_item->mem_flags & LOAD_BALANCE_MEMORY) { |
| j7->memFree(memory_item_old->mem_ptr); |
| memory_item_old->mem_ptr = memory_item_new->mem_ptr; |
| } |
| #endif |
| else { |
| free(memory_item_old->mem_ptr); |
| memory_item_old->mem_ptr = memory_item_new->mem_ptr; |
| } |
| |
| memory_item_old->mem_nelem[0] = memory_item_new->mem_nelem[0]; |
| memory_item_old->mem_capacity = memory_item_new->mem_capacity; |
| memory_item_old->mem_elsize = memory_item_new->mem_elsize; |
| memory_item_old->mem_flags = memory_item_new->mem_flags; |
| malloc_mem_ptr_old = (void *)malloc_mem_ptr_new; |
| free(memory_item_new->mem_nelem); |
| free(memory_item_new->mem_name); |
| free(memory_item_new); |
| |
| memory_ptr_dict.insert(std::pair<void*, malloc_plus_memory_entry*>(malloc_mem_ptr_old, memory_item_old) ); |
| memory_name_dict.insert(std::pair<const char*, malloc_plus_memory_entry*>(memory_item_old->mem_name, memory_item_old) ); |
| |
| return(memory_item_old->mem_ptr); |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| } |
| return(NULL); |
| } |
| |
| void MallocPlus::memory_swap(int **malloc_mem_ptr_old, int **malloc_mem_ptr_new){ |
| map <void *, malloc_plus_memory_entry*>::iterator it_old = memory_ptr_dict.find(*malloc_mem_ptr_old); |
| map <void *, malloc_plus_memory_entry*>::iterator it_new = memory_ptr_dict.find(*malloc_mem_ptr_new); |
| |
| if (it_old != memory_ptr_dict.end() && it_new != memory_ptr_dict.end() ){ |
| // Swap the memory entries during the retrieval |
| malloc_plus_memory_entry *memory_item_new = it_old->second; |
| malloc_plus_memory_entry *memory_item_old = it_new->second; |
| |
| if (DEBUG) printf("Found memory item ptr_old %p name %s ptr_new %p name %s\n",memory_item_old->mem_ptr,memory_item_old->mem_name,memory_item_new->mem_ptr,memory_item_new->mem_name); |
| |
| const char *mem_name_tmp; |
| mem_name_tmp = memory_item_old->mem_name; |
| memory_item_old->mem_name = memory_item_new->mem_name; |
| memory_item_new->mem_name = (char *)mem_name_tmp; |
| |
| // Delete the ptr entries |
| memory_ptr_dict.erase(it_old); |
| memory_ptr_dict.erase(it_new); |
| |
| memory_ptr_dict.insert(std::pair<void *, malloc_plus_memory_entry*>(memory_item_old->mem_ptr, memory_item_old) ); |
| memory_ptr_dict.insert(std::pair<void *, malloc_plus_memory_entry*>(memory_item_new->mem_ptr, memory_item_new) ); |
| |
| // Delete the named entries |
| map <string, malloc_plus_memory_entry*>::iterator it_name_old = memory_name_dict.find(memory_item_old->mem_name); |
| map <string, malloc_plus_memory_entry*>::iterator it_name_new = memory_name_dict.find(memory_item_new->mem_name); |
| memory_name_dict.erase(it_name_old); |
| memory_name_dict.erase(it_name_new); |
| |
| memory_name_dict.insert(std::pair<string, malloc_plus_memory_entry*>(memory_item_old->mem_name, memory_item_old) ); |
| memory_name_dict.insert(std::pair<string, malloc_plus_memory_entry*>(memory_item_new->mem_name, memory_item_new) ); |
| |
| // memory items have been swapped, so return the new pointers |
| *malloc_mem_ptr_old = (int *)memory_item_old->mem_ptr; |
| *malloc_mem_ptr_new = (int *)memory_item_new->mem_ptr; |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| } |
| } |
| |
| void MallocPlus::memory_swap(float **malloc_mem_ptr_old, float **malloc_mem_ptr_new){ |
| map <void *, malloc_plus_memory_entry*>::iterator it_old = memory_ptr_dict.find(*malloc_mem_ptr_old); |
| map <void *, malloc_plus_memory_entry*>::iterator it_new = memory_ptr_dict.find(*malloc_mem_ptr_new); |
| |
| if (it_old != memory_ptr_dict.end() && it_new != memory_ptr_dict.end() ){ |
| // Swap the memory entries during the retrieval |
| malloc_plus_memory_entry *memory_item_new = it_old->second; |
| malloc_plus_memory_entry *memory_item_old = it_new->second; |
| |
| if (DEBUG) printf("Found memory item ptr_old %p name %s ptr_new %p name %s\n",memory_item_old->mem_ptr,memory_item_old->mem_name,memory_item_new->mem_ptr,memory_item_new->mem_name); |
| |
| const char *mem_name_tmp; |
| mem_name_tmp = memory_item_old->mem_name; |
| memory_item_old->mem_name = memory_item_new->mem_name; |
| memory_item_new->mem_name = (char *)mem_name_tmp; |
| |
| // Delete the ptr entries |
| memory_ptr_dict.erase(it_old); |
| memory_ptr_dict.erase(it_new); |
| |
| memory_ptr_dict.insert(std::pair<void *, malloc_plus_memory_entry*>(memory_item_old->mem_ptr, memory_item_old) ); |
| memory_ptr_dict.insert(std::pair<void *, malloc_plus_memory_entry*>(memory_item_new->mem_ptr, memory_item_new) ); |
| |
| // Delete the named entries |
| map <string, malloc_plus_memory_entry*>::iterator it_old = memory_name_dict.find(memory_item_old->mem_name); |
| map <string, malloc_plus_memory_entry*>::iterator it_new = memory_name_dict.find(memory_item_new->mem_name); |
| memory_name_dict.erase(it_old); |
| memory_name_dict.erase(it_new); |
| |
| memory_name_dict.insert(std::pair<string, malloc_plus_memory_entry*>(memory_item_old->mem_name, memory_item_old) ); |
| memory_name_dict.insert(std::pair<string, malloc_plus_memory_entry*>(memory_item_new->mem_name, memory_item_new) ); |
| |
| // memory items have been swapped, so return the new pointers |
| *malloc_mem_ptr_old = (float *)memory_item_old->mem_ptr; |
| *malloc_mem_ptr_new = (float *)memory_item_new->mem_ptr; |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| } |
| } |
| |
| void MallocPlus::memory_swap(double **malloc_mem_ptr_old, double **malloc_mem_ptr_new){ |
| map <void *, malloc_plus_memory_entry*>::iterator it_old = memory_ptr_dict.find(*malloc_mem_ptr_old); |
| map <void *, malloc_plus_memory_entry*>::iterator it_new = memory_ptr_dict.find(*malloc_mem_ptr_new); |
| |
| if (it_old != memory_ptr_dict.end() && it_new != memory_ptr_dict.end() ){ |
| // Swap the memory entries during the retrieval |
| malloc_plus_memory_entry *memory_item_new = it_old->second; |
| malloc_plus_memory_entry *memory_item_old = it_new->second; |
| |
| if (DEBUG) printf("Found memory item ptr_old %p name %s ptr_new %p name %s\n",memory_item_old->mem_ptr,memory_item_old->mem_name,memory_item_new->mem_ptr,memory_item_new->mem_name); |
| |
| const char *mem_name_tmp; |
| mem_name_tmp = memory_item_old->mem_name; |
| memory_item_old->mem_name = memory_item_new->mem_name; |
| memory_item_new->mem_name = (char *)mem_name_tmp; |
| |
| // Delete the ptr entries |
| memory_ptr_dict.erase(it_old); |
| memory_ptr_dict.erase(it_new); |
| |
| memory_ptr_dict.insert(std::pair<void *, malloc_plus_memory_entry*>(memory_item_old->mem_ptr, memory_item_old) ); |
| memory_ptr_dict.insert(std::pair<void *, malloc_plus_memory_entry*>(memory_item_new->mem_ptr, memory_item_new) ); |
| |
| // Delete the named entries |
| map <string, malloc_plus_memory_entry*>::iterator it_old = memory_name_dict.find(memory_item_old->mem_name); |
| map <string, malloc_plus_memory_entry*>::iterator it_new = memory_name_dict.find(memory_item_new->mem_name); |
| memory_name_dict.erase(it_old); |
| memory_name_dict.erase(it_new); |
| |
| memory_name_dict.insert(std::pair<char const *, malloc_plus_memory_entry*>(memory_item_old->mem_name, memory_item_old) ); |
| memory_name_dict.insert(std::pair<char const *, malloc_plus_memory_entry*>(memory_item_new->mem_name, memory_item_new) ); |
| |
| // memory items have been swapped, so return the new pointers |
| *malloc_mem_ptr_old = (double *)memory_item_old->mem_ptr; |
| *malloc_mem_ptr_new = (double *)memory_item_new->mem_ptr; |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| } |
| } |
| |
| // This duplicates memory for a variable and makes a new dictionary entry for the new variable |
| void *MallocPlus::memory_duplicate(void *malloc_mem_ptr, const char *addname){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| void *mem_ptr_dup; |
| |
| if (it != memory_ptr_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| // The memory_malloc will add the database entry |
| mem_ptr_dup = memory_malloc(memory_item->mem_nelem[0], memory_item->mem_elsize, addname, memory_item->mem_flags); |
| return(mem_ptr_dup); |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| } |
| return(NULL); |
| } |
| |
| void *MallocPlus::get_memory_ptr(const char *name){ |
| map <string, malloc_plus_memory_entry*>::iterator it = memory_name_dict.find(name); |
| |
| if (it != memory_name_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("Found memory item ptr %p name %s\n",memory_item->mem_ptr,memory_item->mem_name); |
| return(memory_item->mem_ptr); |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| } |
| return(NULL); |
| } |
| |
| bool MallocPlus::check_memory_attribute(void *malloc_mem_ptr, int attribute){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| |
| if (it != memory_ptr_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("Found memory item ptr %p name %s attribute %d\n",memory_item->mem_ptr,memory_item->mem_name,memory_item->mem_flags); |
| bool bvalue = false; |
| if (memory_item->mem_flags & attribute) bvalue = true; |
| |
| return bvalue; |
| } else { |
| printf("Error -- memory not found\n"); |
| exit(1); |
| } |
| } |
| |
| void MallocPlus::set_memory_attribute(void *malloc_mem_ptr, int attribute){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| |
| if (it != memory_ptr_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("Found memory item ptr %p name %s attribute %d\n",memory_item->mem_ptr,memory_item->mem_name,memory_item->mem_flags); |
| memory_item->mem_flags |= attribute; |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| } |
| } |
| |
| void MallocPlus::clear_memory_attribute(void *malloc_mem_ptr, int attribute){ |
| map <void *, malloc_plus_memory_entry*>::iterator it = memory_ptr_dict.find(malloc_mem_ptr); |
| |
| if (it != memory_ptr_dict.end()){ |
| malloc_plus_memory_entry *memory_item = it->second; |
| |
| if (DEBUG) printf("Found memory item ptr %p name %s attribute %d\n",memory_item->mem_ptr,memory_item->mem_name,memory_item->mem_flags); |
| memory_item->mem_flags &= ~attribute; |
| if (DEBUG) printf("Found memory item ptr %p name %s attribute %d\n",memory_item->mem_ptr,memory_item->mem_name,memory_item->mem_flags); |
| } else { |
| if (DEBUG) printf("Warning -- memory not found\n"); |
| } |
| } |
| |
| extern "C" { |
| MallocPlus *MallocPlus_new(){ |
| return new MallocPlus; |
| } |
| |
| void MallocPlus_memory_report(MallocPlus *mem_object) { |
| mem_object->memory_report(); |
| } |
| |
| void MallocPlus_memory_add(MallocPlus *mem_object, void *dbleptr, size_t nelem, |
| size_t elsize, char *name, unsigned long long flags){ |
| // printf("DEBUG -- nelem %lu elsize %lu\n", nelem, elsize); |
| mem_object->memory_add(dbleptr, nelem, elsize, 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){ |
| // printf("DEBUG -- ndim %d nelem[0] %lu elsize %lu\n",ndim, nelem[0], elsize); |
| mem_object->memory_add(dbleptr, ndim, nelem, elsize, name, |
| (unsigned long long)flags); |
| } |
| } |
