---

perftype.cc

Go to the documentation of this file.

extern "C"
{
#include <stdio.h>
#include <stdlib.h>             /* malloc(), free() */
}

#include "perftype.hh"
#include "rcs_prnt.hh"          /* rcs_print_error() */
#include "cms.hh"               /* CMS */
#include "nml.hh"               /* NML */

unsigned int real_test_msg_size = 0;
unsigned int test_msg_buffer_size = 0;
void *test_msg_buffer = NULL;


// This function exists because sparcworks_sun4 header files
// define free as int free(char *) instead of void free(void *);
static void
corrected_free (void *ptr)
{
#ifdef sparcworks_sun4
  free ((char *) ptr);
#else
  free (ptr);
#endif
}

int
perf_types_format (NMLTYPE type, void *buffer, CMS * cms)
{
  switch (type)
    {
    case NML_PERFORMANCE_TEST_MSG_TYPE:
      ((NML_PERFORMANCE_TEST_MSG *) buffer)->update (cms);
      break;
    default:
      rcs_print_error ("perf_types_format: Unknown Type.(%d) (mode = %d)\n",
                       type, cms->mode);
      return (-1);
    }
  return (0);
}


void
NML_PERFORMANCE_TEST_MSG::update (CMS * cms)
{
  cms->update (serial_number);
  cms->update (test_type);
  cms->update (array_length);
  switch (test_type)
    {
    case CHAR_TEST:
      cms->update (&char_data, (array_length > 0) ? array_length : 1);
      break;
    case SHORT_TEST:
      cms->update (&short_data, (array_length > 0) ? array_length : 1);
      break;
    case INT_TEST:
      cms->update (&int_data, (array_length > 0) ? array_length : 1);
      break;
    case LONG_TEST:
      cms->update (&long_data, (array_length > 0) ? array_length : 1);
      break;
    case FLOAT_TEST:
      cms->update (&float_data, (array_length > 0) ? array_length : 1);
      break;
    case DOUBLE_TEST:
      cms->update (&double_data, (array_length > 0) ? array_length : 1);
      break;
    }
}

void
NML_PERFORMANCE_TEST_MSG::compute_array_length ()
{
  long array_unit_size, base_size, org_size;
  org_size = size;

  switch (test_type)
    {
    case CHAR_TEST:
      array_unit_size = sizeof (char);
      break;
    case SHORT_TEST:
      array_unit_size = sizeof (short);
      break;
    case INT_TEST:
      array_unit_size = sizeof (int);
      break;
    case LONG_TEST:
      array_unit_size = sizeof (long);
      break;
    case FLOAT_TEST:
      array_unit_size = sizeof (float);
      break;
    case DOUBLE_TEST:
      array_unit_size = sizeof (double);
      break;
    default:
      rcs_print_error ("PERFTYPE: Invalid test type. (%ld)\n", test_type);
      array_unit_size = 1;
      break;
    }
  base_size = sizeof (NML_PERFORMANCE_TEST_MSG) - sizeof (double);
  array_length = (size - base_size) / array_unit_size;
  if (array_length > 0)
    {
      size = array_length * array_unit_size + base_size;
    }
  else
    {
      rcs_print_error
        ("NML_PERFORMANCE_TEST_MSG::compute_array_length() - array_length <= 0\n");
    }
}

void *
NML_PERFORMANCE_TEST_MSG::operator new (size_t size)
{
  if (test_msg_buffer_size > size && test_msg_buffer_size > real_test_msg_size
      && test_msg_buffer != NULL)
    {
      return test_msg_buffer;
    }
  if (test_msg_buffer != NULL)
    {
      corrected_free (test_msg_buffer);
      test_msg_buffer = NULL;
    }
  if (real_test_msg_size > size)
    {
      test_msg_buffer_size = real_test_msg_size;
      return (test_msg_buffer = calloc (real_test_msg_size, 1));
    }
  test_msg_buffer_size = size;
  return (test_msg_buffer = calloc (size, 1));
}

void
NML_PERFORMANCE_TEST_MSG::operator delete (void *ptr)
{
  if (ptr != test_msg_buffer && ptr != NULL)
    {
      corrected_free (ptr);
    }
}

void
delete_test_msg_buffer ()
{
  if (NULL != test_msg_buffer)
    {
      corrected_free (test_msg_buffer);
      test_msg_buffer = NULL;
    }
}

void
set_real_test_msg_size (long size)
{
  real_test_msg_size = size;
}

---