コード例 #1
0
ファイル: w32heap.c プロジェクト: betusgarcon/emacs
static char *
allocate_heap (void)
{
  /* Try to get as much as possible of the address range from the end of
     the preload heap section up to the usable address limit.  Since GNU
     malloc can handle gaps in the memory it gets from sbrk, we can
     simply set the sbrk pointer to the base of the new heap region.  */
  DWORD_PTR base =
    ROUND_UP ((RVA_TO_PTR (preload_heap_section->VirtualAddress)
	       + preload_heap_section->Misc.VirtualSize),
	      get_allocation_unit ());
  DWORD_PTR end  = ((unsigned __int64)1) << VALBITS; /* 256MB */
  void *ptr = NULL;

  while (!ptr && (base < end))
    {
#ifdef _WIN64
      reserved_heap_size = min(end - base, 0x4000000000i64); /* Limit to 256Gb */
#else
      reserved_heap_size = end - base;
#endif
      ptr = VirtualAlloc ((void *) base,
			  get_reserved_heap_size (),
			  MEM_RESERVE,
			  PAGE_NOACCESS);
      base += 0x00100000;  /* 1MB increment */
    }

  return ptr;
}
コード例 #2
0
ファイル: w32heap.c プロジェクト: dkogan/emacs-snapshot
void *
mmap_alloc (void **var, size_t nbytes)
{
  void *p = NULL;

  /* We implement amortized allocation.  We start by reserving twice
     the size requested and commit only the size requested.  Then
     realloc could proceed and use the reserved pages, reallocating
     only if needed.  Buffer shrink would happen only so that we stay
     in the 2x range.  This is a big win when visiting compressed
     files, where the final size of the buffer is not known in
     advance, and the buffer is enlarged several times as the data is
     decompressed on the fly.  */
  if (nbytes < MAX_BUFFER_SIZE)
    p = VirtualAlloc (NULL, ROUND_UP (nbytes * 2, get_allocation_unit ()),
		      MEM_RESERVE, PAGE_READWRITE);

  /* If it fails, or if the request is above 512MB, try with the
     requested size.  */
  if (p == NULL)
    p = VirtualAlloc (NULL, ROUND_UP (nbytes, get_allocation_unit ()),
		      MEM_RESERVE, PAGE_READWRITE);

  if (p != NULL)
    {
      /* Now, commit pages for NBYTES.  */
      *var = VirtualAlloc (p, nbytes, MEM_COMMIT, PAGE_READWRITE);
      if (*var == NULL)
	p = *var;
    }

  if (!p)
    {
      DWORD e = GetLastError ();

      if (e == ERROR_NOT_ENOUGH_MEMORY)
	errno = ENOMEM;
      else
	{
	  DebPrint (("mmap_alloc: error %ld\n", e));
	  errno = EINVAL;
	}
    }

  return *var = p;
}
コード例 #3
0
ファイル: file_write.c プロジェクト: hlabanca/L3info
/* SYNOPSYS :
 * 	  int syr1_fopen_write(char *name, SYR1_FILE *file) {
 * DESCRIPTION :
 *   Ce sous-programme gère l'ouverture d'un fichier logique en mode écriture.
 * PARAMETRES :
 *   name : chaîne de caratère contenant le nom externe du fichier à ouvrir
 *   file : pointeur sur un Bloc Control Fichier (File Control Bloc)
 * RESULTAT :
 *    0 : ouverture réussie
 *   -1 : autre erreur
 */
int syr1_fopen_write(char *name, SYR1_FILE *file) {
  int error = 0;
  //Si le fichier existe déjà, suppression
  if(search_entry(name, &(file->descriptor)) == 0)
	remove_entry(name);
  //initialisation du descripteur
  strcpy(file->descriptor.name, name);
  file->descriptor.size = 0;
  file->descriptor.alloc[0] = get_allocation_unit();
  //création du fichier sur disque
  create_entry(name, &(file->descriptor));
  //initialisation du BCF
  strcpy(file->mode, "w");
  file->current_block = 0;
  file->file_offset = 0;
  file->block_offset = 0;
  file->buffer = malloc(512*sizeof(unsigned char));

  return -1;
}