C++ (Cpp) outOfCore 예제들

예제 #1

파일: pl-alloc.c 프로젝트: brayc0/nlfetdb

void *
allocHeapOrHalt(size_t n)
{ void *mem = allocHeap(n);

  if ( !mem )
    outOfCore();

  return mem;
}

예제 #2

파일: pl-indirect.c 프로젝트: SWI-Prolog/swipl

static void
allocate_indirect_block(indirect_table *tab, int idx)
{ simpleMutexLock(&tab->mutex);
  if ( !tab->array.blocks[idx] )
  { size_t bs = (size_t)1<<idx;
    indirect *newblock;

    if ( !(newblock=PL_malloc(bs*sizeof(*newblock))) )
      outOfCore();

    memset(newblock, 0, bs*sizeof(*newblock));
    tab->array.blocks[idx] = newblock-bs;
  }
  simpleMutexUnlock(&tab->mutex);
}

예제 #3

파일: pl-atom.c 프로젝트: JorgeG1/swipl-devel

static void
allocateAtomBlock(int idx)
{
  PL_LOCK(L_MISC);

  if ( !GD->atoms.array.blocks[idx] )
  { size_t bs = (size_t)1<<idx;
    Atom newblock;

    if ( !(newblock=PL_malloc_uncollectable(bs*sizeof(struct atom))) )
      outOfCore();

    memset(newblock, 0, bs*sizeof(struct atom));
    GD->atoms.array.blocks[idx] = newblock-bs;
  }

  PL_UNLOCK(L_MISC);
}

예제 #4

파일: pl-funct.c 프로젝트: DouglasRMiles/swipl-devel

static void
allocateFunctorBlock(int idx)
{
  PL_LOCK(L_MISC);

  if ( !GD->functors.array.blocks[idx] )
  { size_t bs = (size_t)1<<idx;
    FunctorDef *newblock;

    if ( !(newblock=PL_malloc_uncollectable(bs*sizeof(FunctorDef))) )
      outOfCore();

    memset(newblock, 0, bs*sizeof(FunctorDef));
    GD->functors.array.blocks[idx] = newblock-bs;
  }

  PL_UNLOCK(L_MISC);
}

예제 #5

파일: pl-srcfile.c 프로젝트: JorgeG1/swipl-devel

static void
putSourceFileArray(size_t where, SourceFile sf)
{ int idx = MSB(where);

  if ( !GD->files.array.blocks[idx] )
  { PL_LOCK(L_MISC);
    if ( !GD->files.array.blocks[idx] )
    { size_t bs = (size_t)1<<idx;
      SourceFile *newblock;

      if ( !(newblock=PL_malloc_uncollectable(bs*sizeof(SourceFile))) )
	outOfCore();

      memset(newblock, 0, bs*sizeof(SourceFile));
      GD->files.array.blocks[idx] = newblock-bs;
    }
    PL_UNLOCK(L_MISC);
  }

  GD->files.array.blocks[idx][where] = sf;
}

예제 #6

파일: pl-atom.c 프로젝트: bsmr-swi-prolog/swipl

static void
putAtomArray(size_t where, Atom a)
{ int idx = MSB(where);

  assert(where >= 0);

  if ( !GD->atoms.array.blocks[idx] )
  { PL_LOCK(L_MISC);
    if ( !GD->atoms.array.blocks[idx] )
    { size_t bs = (size_t)1<<idx;
      Atom *newblock;

      if ( !(newblock=PL_malloc_uncollectable(bs*sizeof(Atom))) )
	outOfCore();

      memset(newblock, 0, bs*sizeof(Atom));
      GD->atoms.array.blocks[idx] = newblock-bs;
    }
    PL_UNLOCK(L_MISC);
  }

  GD->atoms.array.blocks[idx][where] = a;
}

예제 #7

파일: pl-funct.c 프로젝트: flbulgarelli/swipl

static void
putFunctorArray(size_t where, FunctorDef fd)
{ int idx = MSB(where);

  assert(where >= 0);

  if ( !GD->functors.array.blocks[idx] )
  { PL_LOCK(L_MISC);
    if ( !GD->functors.array.blocks[idx] )
    { size_t bs = (size_t)1<<idx;
      FunctorDef *newblock;

      if ( !(newblock=PL_malloc_uncollectable(bs*sizeof(FunctorDef))) )
	outOfCore();

      memset(newblock, 0, bs*sizeof(FunctorDef));
      GD->functors.array.blocks[idx] = newblock-bs;
    }
    PL_UNLOCK(L_MISC);
  }

  GD->functors.array.blocks[idx][where] = fd;
}

예제 #8

파일: pl-gmp.c 프로젝트: SWI-Prolog/swipl

void
addMPZToBuffer(Buffer b, mpz_t mpz)
{ size_t size = (mpz_sizeinbase(mpz, 2)+7)/8;
  ssize_t hdrsize;
  size_t count;

  if ( !growBuffer(b, size+4) )
    outOfCore();
  if ( mpz_sgn(mpz) < 0 )
    hdrsize = -(ssize_t)size;
  else
    hdrsize = (ssize_t)size;
  DEBUG(1, Sdprintf("addMPZToBuffer(): Added %d bytes\n", size));

  *b->top++ = (char)((hdrsize>>24)&0xff);
  *b->top++ = (char)((hdrsize>>16)&0xff);
  *b->top++ = (char)((hdrsize>> 8)&0xff);
  *b->top++ = (char)((hdrsize    )&0xff);

  mpz_export(b->top, &count, 1, 1, 1, 0, mpz);
  assert(count == size);
  b->top = b->top + size;
}