diff -r d59bea55db9b -r c445c931472f src/glpenv05.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/glpenv05.c Mon Dec 06 13:09:21 2010 +0100 @@ -0,0 +1,225 @@ +/* glpenv05.c (memory allocation) */ + +/*********************************************************************** +* This code is part of GLPK (GNU Linear Programming Kit). +* +* Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, +* 2009, 2010 Andrew Makhorin, Department for Applied Informatics, +* Moscow Aviation Institute, Moscow, Russia. All rights reserved. +* E-mail: . +* +* GLPK is free software: you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* GLPK is distributed in the hope that it will be useful, but WITHOUT +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY +* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public +* License for more details. +* +* You should have received a copy of the GNU General Public License +* along with GLPK. If not, see . +***********************************************************************/ + +#include "glpapi.h" + +/* some processors need data to be properly aligned; the macro + align_datasize enlarges the specified size of a data item to provide + a proper alignment of immediately following data */ + +#define align_datasize(size) ((((size) + 15) / 16) * 16) +/* 16 bytes is sufficient in both 32- and 64-bit environments + (8 bytes is not sufficient in 64-bit environment due to jmp_buf) */ + +/*********************************************************************** +* NAME +* +* glp_malloc - allocate memory block +* +* SYNOPSIS +* +* void *glp_malloc(int size); +* +* DESCRIPTION +* +* The routine glp_malloc allocates a memory block of size bytes long. +* +* Note that being allocated the memory block contains arbitrary data +* (not binary zeros). +* +* RETURNS +* +* The routine glp_malloc returns a pointer to the allocated block. +* To free this block the routine glp_free (not free!) must be used. */ + +void *glp_malloc(int size) +{ ENV *env = get_env_ptr(); + MEM *desc; + int size_of_desc = align_datasize(sizeof(MEM)); + if (size < 1 || size > INT_MAX - size_of_desc) + xerror("glp_malloc: size = %d; invalid parameter\n", size); + size += size_of_desc; + if (xlcmp(xlset(size), + xlsub(env->mem_limit, env->mem_total)) > 0) + xerror("glp_malloc: memory limit exceeded\n"); + if (env->mem_count == INT_MAX) + xerror("glp_malloc: too many memory blocks allocated\n"); + desc = malloc(size); + if (desc == NULL) + xerror("glp_malloc: no memory available\n"); + memset(desc, '?', size); + desc->flag = MEM_MAGIC; + desc->size = size; + desc->prev = NULL; + desc->next = env->mem_ptr; + if (desc->next != NULL) desc->next->prev = desc; + env->mem_ptr = desc; + env->mem_count++; + if (env->mem_cpeak < env->mem_count) + env->mem_cpeak = env->mem_count; + env->mem_total = xladd(env->mem_total, xlset(size)); + if (xlcmp(env->mem_tpeak, env->mem_total) < 0) + env->mem_tpeak = env->mem_total; + return (void *)((char *)desc + size_of_desc); +} + +/*********************************************************************** +* NAME +* +* glp_calloc - allocate memory block +* +* SYNOPSIS +* +* void *glp_calloc(int n, int size); +* +* DESCRIPTION +* +* The routine glp_calloc allocates a memory block of (n*size) bytes +* long. +* +* Note that being allocated the memory block contains arbitrary data +* (not binary zeros). +* +* RETURNS +* +* The routine glp_calloc returns a pointer to the allocated block. +* To free this block the routine glp_free (not free!) must be used. */ + +void *glp_calloc(int n, int size) +{ if (n < 1) + xerror("glp_calloc: n = %d; invalid parameter\n", n); + if (size < 1) + xerror("glp_calloc: size = %d; invalid parameter\n", size); + if (n > INT_MAX / size) + xerror("glp_calloc: n = %d; size = %d; array too big\n", n, + size); + return xmalloc(n * size); +} + +/*********************************************************************** +* NAME +* +* glp_free - free memory block +* +* SYNOPSIS +* +* void glp_free(void *ptr); +* +* DESCRIPTION +* +* The routine glp_free frees a memory block pointed to by ptr, which +* was previuosly allocated by the routine glp_malloc or glp_calloc. */ + +void glp_free(void *ptr) +{ ENV *env = get_env_ptr(); + MEM *desc; + int size_of_desc = align_datasize(sizeof(MEM)); + if (ptr == NULL) + xerror("glp_free: ptr = %p; null pointer\n", ptr); + desc = (void *)((char *)ptr - size_of_desc); + if (desc->flag != MEM_MAGIC) + xerror("glp_free: ptr = %p; invalid pointer\n", ptr); + if (env->mem_count == 0 || + xlcmp(env->mem_total, xlset(desc->size)) < 0) + xerror("glp_free: memory allocation error\n"); + if (desc->prev == NULL) + env->mem_ptr = desc->next; + else + desc->prev->next = desc->next; + if (desc->next == NULL) + ; + else + desc->next->prev = desc->prev; + env->mem_count--; + env->mem_total = xlsub(env->mem_total, xlset(desc->size)); + memset(desc, '?', size_of_desc); + free(desc); + return; +} + +/*********************************************************************** +* NAME +* +* glp_mem_limit - set memory usage limit +* +* SYNOPSIS +* +* void glp_mem_limit(int limit); +* +* DESCRIPTION +* +* The routine glp_mem_limit limits the amount of memory available for +* dynamic allocation (in GLPK routines) to limit megabytes. */ + +void glp_mem_limit(int limit) +{ ENV *env = get_env_ptr(); + if (limit < 0) + xerror("glp_mem_limit: limit = %d; invalid parameter\n", + limit); + env->mem_limit = xlmul(xlset(limit), xlset(1 << 20)); + return; +} + +/*********************************************************************** +* NAME +* +* glp_mem_usage - get memory usage information +* +* SYNOPSIS +* +* void glp_mem_usage(int *count, int *cpeak, glp_long *total, +* glp_long *tpeak); +* +* DESCRIPTION +* +* The routine glp_mem_usage reports some information about utilization +* of the memory by GLPK routines. Information is stored to locations +* specified by corresponding parameters (see below). Any parameter can +* be specified as NULL, in which case corresponding information is not +* stored. +* +* *count is the number of the memory blocks currently allocated by the +* routines xmalloc and xcalloc (one call to xmalloc or xcalloc results +* in allocating one memory block). +* +* *cpeak is the peak value of *count reached since the initialization +* of the GLPK library environment. +* +* *total is the total amount, in bytes, of the memory blocks currently +* allocated by the routines xmalloc and xcalloc. +* +* *tpeak is the peak value of *total reached since the initialization +* of the GLPK library envirionment. */ + +void glp_mem_usage(int *count, int *cpeak, glp_long *total, + glp_long *tpeak) +{ ENV *env = get_env_ptr(); + if (count != NULL) *count = env->mem_count; + if (cpeak != NULL) *cpeak = env->mem_cpeak; + if (total != NULL) *total = env->mem_total; + if (tpeak != NULL) *tpeak = env->mem_tpeak; + return; +} + +/* eof */