scilab/modules/core/sci_gateway/c/sci_stacksize.c

   1 /*
   2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3 * Copyright (C) 2006 - INRIA - Allan CORNET
   4 * Copyright (C) 2009-2010 - DIGITEO - Allan CORNET
   5 *
   6 * This file must be used under the terms of the CeCILL.
   7 * This source file is licensed as described in the file COPYING, which
   8 * you should have received as part of this distribution.  The terms
   9 * are also available at
  10 * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  11 *
  12 */
  13 #ifdef _MSC_VER
  14 #include <Windows.h>
  15 #else
  16 #include <unistd.h>
  17 #include <sys/sysinfo.h>
  18 #endif
  19 #include <stdio.h>
  20
  21 #include "gw_core.h"
  22 #include "stack-c.h"
  23 #include "MALLOC.h"
  24 #include "getmaxMALLOC.h"
  25 #include "scimem.h"
  26 #include "localization.h"
  27 #include "stackinfo.h"
  28 #include "Scierror.h"
  29 #include "dynamic_parallel.h"
  30 /*--------------------------------------------------------------------------*/
  31 extern int C2F(adjuststacksize) ();
  32
  33 /*--------------------------------------------------------------------------*/
  34 #define MIN_STACKSIZE 180000
  35 #define PARAM_MAX_STR "max"
  36 #define PARAM_MIN_STR "min"
  37 /*--------------------------------------------------------------------------*/
  38 static int sci_stacksizeNoRhs(char *fname);
  39 static int sci_stacksizeOneRhs(char *fname);
  40 static int sci_stacksizeMax(char *fname);
  41 static int sci_stacksizeMin(char *fname);
  42 static int setStacksizeMin(char *fname);
  43 static int setStacksizeMax(char *fname);
  44 static int setStacksize(unsigned long newsize);
  45 static unsigned long getCurrentStacksize(void);
  46 static unsigned long getUsedStacksize(void);
  47 static char *getStackCreationErrorMessage(int errCode);
  48
  49 /*--------------------------------------------------------------------------*/
  50 /**
  51 * stacksize - set scilab stack size
  52 * Calling Sequence
  53 * stacksize(n)
  54 * stacksize('max')
  55 * stacksize('min')
  56 * sz=stacksize()
  57 * Parameters
  58 * n : integer, the required stack size given in number of double precision words
  59 * 'max' : try to allocate the maximum of memory
  60 * 'max' : allocate the minimum of memory
  61 * sz : 2-vector [total used]
  62 */
  63 /*--------------------------------------------------------------------------*/
  64 int C2F(sci_stacksize) (char *fname, unsigned long fname_len)
  65 {
  66
  67     Rhs = Max(0, Rhs);
  68     CheckRhs(0, 1);
  69     CheckLhs(0, 1);
  70
  71     if (Rhs == 0)
  72     {
  73         return sci_stacksizeNoRhs(fname);
  74     }
  75     return dynParallelConcurrency() ? dynParallelForbidden(fname) : sci_stacksizeOneRhs(fname);
  76 }
  77
  78 /*--------------------------------------------------------------------------*/
  79 static int sci_stacksizeNoRhs(char *fname)
  80 {
  81     int n1 = 0, m1 = 0;
  82     int *paramoutINT = NULL;
  83     int total = 0;
  84     int used = 0;
  85
  86     paramoutINT = (int *)MALLOC(sizeof(int) * 2);
  87
  88     C2F(getstackinfo) (&total, &used);
  89     paramoutINT[0] = total;
  90     paramoutINT[1] = used;
  91
  92     n1 = 1;
  93     m1 = 2;
  94     CreateVarFromPtr(Rhs + 1, MATRIX_OF_INTEGER_DATATYPE, &n1, &m1, (int *)&paramoutINT);
  95
  96     LhsVar(1) = Rhs + 1;
  97
  98     if (paramoutINT)
  99     {
 100         FREE(paramoutINT);
 101         paramoutINT = NULL;
 102     }
 103
 104     PutLhsVar();
 105     return 0;
 106 }
 107
 108 /*--------------------------------------------------------------------------*/
 109 static int sci_stacksizeOneRhs(char *fname)
 110 {
 111     int l1 = 0, n1 = 0, m1 = 0;
 112     int errCode = 0;
 113
 114     if (GetType(1) == sci_matrix)
 115     {
 116         GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
 117         if ((m1 == 1) && (n1 == 1))
 118         {
 119             unsigned long NEWMEMSTACKSIZE = (unsigned long) * stk(l1);
 120
 121             /* add 1 for alignment problems */
 122             if (is_a_valid_size_for_scilab_stack(NEWMEMSTACKSIZE + 1))
 123             {
 124                 if ((NEWMEMSTACKSIZE >= MIN_STACKSIZE) && (NEWMEMSTACKSIZE <= get_max_memory_for_scilab_stack()))
 125                 {
 126                     /* we backup previous size */
 127                     unsigned long backupSize = getCurrentStacksize();
 128
 129                     errCode = setStacksizeMin(fname);
 130                     if (errCode == 0)
 131                     {
 132                         errCode = setStacksize(NEWMEMSTACKSIZE);
 133                         if (errCode == 0)
 134                         {
 135                             LhsVar(1) = 0;
 136                             PutLhsVar();
 137                             return 0;
 138                         }
 139                         else
 140                         {
 141                             /* restore previous size */
 142                             setStacksize(backupSize);
 143                             Scierror(10001, _("%s: Cannot allocate memory.\n%s\n"), fname, getStackCreationErrorMessage(errCode));
 144                         }
 145                     }
 146                     else
 147                     {
 148                         /* restore previous size */
 149                         setStacksize(backupSize);
 150                         Scierror(10001, _("%s: Cannot allocate memory.\n%s\n"), fname, getStackCreationErrorMessage(errCode));
 151                     }
 152
 153                 }
 154                 else
 155                 {
 156                     Scierror(1504, _("%s: Out of bounds value. Not in [%lu,%lu].\n"), fname, MIN_STACKSIZE, get_max_memory_for_scilab_stack() - 1);
 157                 }
 158             }
 159             else
 160             {
 161                 Scierror(1504, _("%s: Out of bounds value. Not in [%lu,%lu].\n"), fname, MIN_STACKSIZE, get_max_memory_for_scilab_stack() - 1);
 162             }
 163         }
 164         else
 165         {
 166             Scierror(204, _("%s: Wrong size for input argument #%d: Scalar expected.\n"), fname, 1);
 167         }
 168     }
 169     else if (GetType(1) == sci_strings)
 170     {
 171         char *param = NULL;
 172
 173         GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
 174         param = cstk(l1);
 175         if (strcmp(PARAM_MAX_STR, param) == 0)
 176         {
 177             return sci_stacksizeMax(fname);
 178         }
 179         else if (strcmp(PARAM_MIN_STR, param) == 0)
 180         {
 181             return sci_stacksizeMin(fname);
 182         }
 183         else
 184         {
 185             Scierror(204, _("%s: Wrong type for input argument #%d: Scalar, '%s' or '%s'.\n"), fname, 1, "min", "max");
 186         }
 187     }
 188     else
 189     {
 190         Scierror(204, _("%s: Wrong type for input argument #%d: Scalar, '%s' or '%s'.\n"), fname, 1, "min", "max");
 191     }
 192     return 0;
 193 }
 194
 195 /*--------------------------------------------------------------------------*/
 196 static int sci_stacksizeMax(char *fname)
 197 {
 198     if (setStacksizeMax(fname) == 0)
 199     {
 200         LhsVar(1) = 0;
 201         PutLhsVar();
 202     }
 203     else
 204     {
 205         Scierror(10001, _("%s: Cannot allocate memory.\n"), fname);
 206     }
 207     return 0;
 208 }
 209
 210 /*--------------------------------------------------------------------------*/
 211 static int sci_stacksizeMin(char *fname)
 212 {
 213     if (setStacksizeMin(fname) == 0)
 214     {
 215         LhsVar(1) = 0;
 216         PutLhsVar();
 217     }
 218     else
 219     {
 220         Scierror(10001, _("%s: Cannot allocate memory.\n"), fname);
 221     }
 222     return 0;
 223 }
 224
 225 /*--------------------------------------------------------------------------*/
 226 static int setStacksizeMin(char *fname)
 227 {
 228     unsigned long memstackused = getUsedStacksize();
 229
 230     if (memstackused < MIN_STACKSIZE)
 231     {
 232         return setStacksize(MIN_STACKSIZE);
 233     }
 234     else
 235     {
 236         /* Add 3000 security for the stack */
 237         return setStacksize(memstackused + 3000);
 238     }
 239 }
 240
 241 /*--------------------------------------------------------------------------*/
 242 static int setStacksizeMax(char *fname)
 243 {
 244     /* we backup previous size */
 245     unsigned long backupSize = getCurrentStacksize();
 246
 247     /* Bug 5495 on Windows 2000 -- WONT FIX GetLargestFreeMemoryRegion */
 248     /* it works on XP, Vista, S7ven */
 249     /* GetLargestFreeMemoryRegion() returns a superior size to real value */
 250     unsigned long maxmemfree = (GetLargestFreeMemoryRegion()) / sizeof(double);
 251
 252     long long freePhysicalMem = 0;
 253 #ifdef _MSC_VER
 254     MEMORYSTATUSEX statex;
 255     statex.dwLength = sizeof (statex);
 256     GlobalMemoryStatusEx (&statex);
 257     //do not exceed available free memory
 258
 259     //use min value between max memory available and max "allocable" memory by Scilab
 260
 261     freePhysicalMem =  (long long)(statex.ullAvailPageFile / sizeof(double));
 262     //if free memory is used, keep 10% to OS
 263 #else
 264     freePhysicalMem = (long long)((get_avphys_pages() * get_phys_pages()) / sizeof(double));
 265 #endif
 266
 267     if (freePhysicalMem > 0 && freePhysicalMem < maxmemfree)
 268     {
 269         maxmemfree = (unsigned long)(freePhysicalMem * 0.9);
 270     }
 271
 272     /* We have already max */
 273     if (maxmemfree <= backupSize)
 274     {
 275         LhsVar(1) = 0;
 276         C2F(putlhsvar) ();
 277         return 0;
 278     }
 279
 280     /* we do a stacksize('min') */
 281     if (setStacksizeMin(fname) == 0)
 282     {
 283         unsigned long memmaxavailablebyscilab = get_max_memory_for_scilab_stack();
 284         unsigned long newMemSizeMax = maxmemfree;
 285         int errCode;
 286
 287         if (memmaxavailablebyscilab < newMemSizeMax)
 288         {
 289             newMemSizeMax = memmaxavailablebyscilab;
 290         }
 291
 292         if (newMemSizeMax < MIN_STACKSIZE)
 293         {
 294             newMemSizeMax = MIN_STACKSIZE;
 295         }
 296
 297         errCode = setStacksize(newMemSizeMax);
 298         if (errCode != 0)
 299         {
 300             setStacksize(backupSize);
 301             Scierror(10001, _("%s: Cannot allocate memory.\n%s\n"), fname, getStackCreationErrorMessage(errCode));
 302         }
 303         return 0;
 304     }
 305     else
 306     {
 307         /* stacksize('min') fails */
 308         /* restore previous size */
 309         setStacksize(backupSize);
 310         Scierror(10001, _("%s: Cannot allocate memory.\n"), fname);
 311     }
 312     return 0;
 313 }
 314
 315 /*--------------------------------------------------------------------------*/
 316 /*
 317  *
 318  * @return 0 if success
 319  *         -1 if cannot allocate this quantity of memory
 320  *         -2 if the requested size is smaller than the minimal one
 321  *         -3 unable to create (or resize) the stack (probably a malloc error
 322  */
 323 static int setStacksize(unsigned long newsize)
 324 {
 325     if (newsize != getCurrentStacksize())
 326     {
 327         if ((newsize >= MIN_STACKSIZE))
 328         {
 329             if ((newsize <= get_max_memory_for_scilab_stack()))
 330             {
 331                 unsigned long ptr = 0;
 332
 333                 C2F(scimem) (&newsize, &ptr);
 334                 if (ptr)
 335                 {
 336                     LhsVar(1) = 0;
 337                     C2F(putlhsvar) ();
 338
 339                     C2F(adjuststacksize) (&newsize, &ptr);
 340                     return 0;
 341                 }
 342                 return -3;      /* We haven't been able to create (or resize) the stack (probably a malloc error */
 343             }
 344             /* Not possible to assign that amount of memory */
 345             return -1;
 346         }
 347         /* Trying to create a too small stack */
 348         return -2;
 349     }
 350     /* Set the stacksize to the same size... No need to do anything */
 351     return 0;
 352 }
 353
 354 /*--------------------------------------------------------------------------*/
 355 static unsigned long getCurrentStacksize(void)
 356 {
 357     unsigned long memstacktotal = 0;
 358     unsigned long memstackused = 0;
 359
 360     C2F(getstackinfo) (&memstacktotal, &memstackused);
 361
 362     return memstacktotal;
 363 }
 364
 365 /*--------------------------------------------------------------------------*/
 366 static unsigned long getUsedStacksize(void)
 367 {
 368     unsigned long memstacktotal = 0;
 369     unsigned long memstackused = 0;
 370
 371     C2F(getstackinfo) (&memstacktotal, &memstackused);
 372
 373     return memstackused;
 374 }
 375
 376 /*--------------------------------------------------------------------------*/
 377
 378 static char *getStackCreationErrorMessage(int errCode)
 379 {
 380     switch (errCode)
 381     {
 382         case -1:
 383             return _("%s: Cannot allocate this quantity of memory.\n");
 384             break;
 385         case -2:
 386             return _("%s: The requested size is smaller than the minimal one.\n");
 387             break;
 388         case -3:
 389             return _("%s: Unable to create (or resize) the stack (probably a malloc error).\n");
 390             break;
 391     }
 392     return _("%s: Unknown error.\n");
 393 }
 394
 395 /*--------------------------------------------------------------------------*/