t_shared_memory.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_shared_memory                                                *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2003-$now By Author.  This program 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 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include <basis/byte_array.h>
#include <basis/chaos.h>
#include <basis/function.h>
#include <basis/guards.h>
#include <basis/istring.h>
#include <opsystem/application_shell.h>
#include <loggers/console_logger.h>
#include <opsystem/filename.h>
#include <opsystem/shared_memory.h>
#include <data_struct/static_memory_gremlin.h>

const int CHUNKING_SIZE = 20 * KILOBYTE;
  // the size of the area we examine at one time.

class test_shared_memory : public application_shell
{
public:
  test_shared_memory() : application_shell(class_name()) {}
  IMPLEMENT_CLASS_NAME("test_shared_memory");
  virtual int execute();
};

// this never returns zero so we can assume a zero is original contents.
int zingle(int base)
{
  return (base * 7 + 23108) % 255 + 1;
}

int test_shared_memory::execute()
{
  FUNCDEF("execute");
  const int chunk_size = 1208227;
  shared_memory biggy_chunk(chunk_size, const_cast<char *>(class_name()));

  byte *mem = biggy_chunk.lock();
  if (!mem)
    deadly_error(class_name(), func,
        "allocation failure--could not create our shared memory chunk.");
  if (biggy_chunk.first_usage(mem, 100)) {
    // prepare the chunk in some manner, if needed.
  }
  biggy_chunk.unlock(mem);

  // iterate through the chunk and verify the values.
  for (int i = 0; i < chunk_size; i += CHUNKING_SIZE) {
    byte *mem = biggy_chunk.lock();

    if (!mem[i]) {
      // this area hasn't been set yet, so we'll write it in now.
      for (int j = 0; j < CHUNKING_SIZE; j++) {
        // verify that all bytes are zero for the range.
        if (mem[i + j])
          deadly_error(class_name(), func,
              "value failure--non-zero value in range where zero is required.");
        // use the offset to set a new value in our range.
        mem[i + j] = zingle(i + j);
      }
      // now we'll fall through to the snooze.
    } else {
      // this area has some kind of content.  let's test that it's valid.
      for (int j = 0; j < CHUNKING_SIZE; j++) {
        // check a value at this offset.
        if (mem[i + j] != zingle(i + j))
          deadly_error(class_name(), func,
              "value failure--this range has an incorrect value.");
      }
      // since we liked the values in this range, we can keep going and catch
      // up to other apps doing this by not snoozing.
      biggy_chunk.unlock(mem);
      continue;
    }

    biggy_chunk.unlock(mem);
    // now we snooze for a bit since this is designed to work with other
    // programs who could steal a range.
    int nap_length = randomizer().inclusive(10, 300);
    portable::sleep_ms(nap_length);
  }

  guards::alert_message("shared_memory:: works for those functions tested.\n");
  return 0;
}

HOOPLE_MAIN(test_shared_memory, )

---