C++ (Cpp) SASJoinRegion Examples

Example #1

File: example_sasindex.c Project: ktangwon/sphde

int
main (int argc, char *argv[])
{
  SASIndex_t index;
  int rc;

  rc = SASJoinRegion();
  if (rc != 0)
    {
      fprintf (stderr, "%s: SASJoinRegion failed: %d\n", progName, rc);
      exit (EXIT_FAILURE);
    }

  index = SASIndexCreate (block__Size256K);
  if (index == 0)
    {
      fprintf (stderr, "%s: SASIndexCreate(%li) failed\n", progName,
	       block__Size256K);
      exit (EXIT_FAILURE);
    }

  sasindex_add_element (index, 'a', "1");
  sasindex_add_element (index, 'b', "2");
  sasindex_add_element (index, 'c', "3");

  sasindex_print (index);
  sasindex_print_enum (index);

  SASCleanUp ();

  return 0;
}

Example #2

File: sphsinglepcqueue_tt.c Project: ktangwon/sphde

int
main ()
{
  int rc;

  SAS_IO_INIT			// init the io stuff
    rc = SASJoinRegion ();

  if (rc)
    {
      printf ("SASJoinRegion Error# %d\n", rc);

      return 1;
    }
  else
    {
      printf ("SAS Joined\n");

      rc += test_unit (128);
      rc += test_unit (3 * 128);

      rc += test_unitfast (128);
      rc += test_unitfast (3 * 128);
    }

  //SASCleanUp();
  printf ("SAS removed\n");
  SASRemove ();
  return rc;
};

Example #3

File: sasstringbtree_t.c Project: ThinkOpenly/sphde

int
main ()
{
  int rc;
  int failures = 0;

  if ((rc = SASJoinRegion ()))
    {
      SASSIM_PRINT_ERR ("SASJoinRegion: %i", rc);
      exit (JOIN_EXIT_FAILURE);
    }
  printf ("__SAS_BASE_ADDRESS=%lx\n", __SAS_BASE_ADDRESS);
  printf ("RegionSize        =%lx\n", RegionSize);
  printf ("SegmentSize       =%lx\n", SegmentSize);
  printf ("__SAS_TEMP_ADDRESS=%lx\n", __SAS_TEMP_ADDRESS);
  printf ("__SAS_TEMP_FREE   =%lx\n", __SAS_TEMP_FREE);

  failures += sassim_btree_test1 ();
  failures += sassim_btree_test_split();

  //SASCleanUp();
  printf("SAS removed\n");
  SASRemove();

  return failures;
}

Example #4

File: example_sph_2_1.c Project: ktangwon/sphde

int main()
{
  SASSimpleHeap_t heap;
  void **blockDescriptor;
  size_t blockDescriptorCount;
  int rc, i;

  /* Init a SPHDE region: create and attach the control shared memory 
   * segment and locks. */
  rc = SASJoinRegion();
  if (rc != 0) {
    fprintf(stderr, "%s: error: SASJoinRegion: %d\n", progName, rc);
    exit(EXIT_FAILURE);
  }

  /* Now it allocates a vector descriptor: the trick is SASSimpleHeap_t
   * allocates a control header of size 'heap_offset':
   * (1MB - heap_offset)/16KB == 63 entries
   *   32 bits -> 63*sizeof(void*) == 252 bytes 
   *   64 bits -> 63*sizeof(void*) == 504 bytes 
   * So it used a block of 512 to work on both 32 and 64 bits */
  blockDescriptor = SASBlockAlloc(block__Size512);
  printf("%s: SASBlockAlloc(%lu) ", progName, block__Size512);
  if (!blockDescriptor) {
    printf("failed\n");
    exit(EXIT_FAILURE);
  }
  printf("succeed: %p\n", blockDescriptor);

  heap = SASSimpleHeapCreate(kHeapSize);
  printf("%s: SASSimpleHeapCreate(%zu) ", progName, kHeapSize);
  if (!heap) {
    printf("failed\n");
    exit(EXIT_FAILURE);
  }
  printf("succeed: %p\n", heap);

  /* And finally allocates each memory chunk. */
  blockDescriptorCount = (block__Size1M - heap_offset) / kBlockSize;
  for (i=0; i<blockDescriptorCount; ++i) {
    blockDescriptor[i] = SASSimpleHeapAlloc(heap, kBlockSize);
    if (!blockDescriptor[i]) {
      printf("%s: blockDescriptor[%d] = SASSimpleHeapAlloc(%p, %zu) failed\n",
	     progName, i, heap, kBlockSize);
      exit(EXIT_FAILURE);
    }
    memset(blockDescriptor[i], i, kBlockSize);
  }
  printf("%s: SASSimpleHeapFreeSpace(%p): %zu\n", progName, heap,
         SASSimpleHeapFreeSpace(heap));

  SASSimpleHeapDestroy(heap);
  printf("%s: SASSimpleHeapDestroy(%p)\n", progName, heap);

  SASBlockDealloc(blockDescriptor, block__Size512);
  printf("%s: SASBlockDealloc(%p, %lu)\n", progName, blockDescriptor,
	 block__Size512);

  SASCleanUp();

  return 0;
}