test_conformance/mem_host_flags/C_host_memory_block.h

//
// Copyright (c) 2017 The Khronos Group Inc.
// 
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#ifndef test_conformance_cHost_MemoryBlock_h
#define test_conformance_cHost_MemoryBlock_h

#include "harness/compat.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

template < class T> class C_host_memory_block
{
public:
  int num_elements;
  int element_size;
  T *pData;

  C_host_memory_block();
  ~C_host_memory_block();
  void Init(int num_elem, T &value);
  void Init(int num_elem);
  void Set_to(T & val);
  void Set_to_zero();
  bool Equal_to(T &val);
  size_t Count(T &val);
  bool Equal(C_host_memory_block < T > & another);
  bool Equal_rect(C_host_memory_block < T > & another,
                  size_t * host_origin,
                  size_t * region,
                  size_t host_row_pitch,
                  size_t host_slice_pitch);
  bool Equal(T *pData, int num_elements);

  bool Equal_rect_from_orig(C_host_memory_block < T > & another,
                            size_t * soffset,
                            size_t * region,
                            size_t host_row_pitch,
                            size_t host_slice_pitch);

  bool Equal_rect_from_orig(T* another_pdata,
                            size_t * soffset,
                            size_t * region,
                            size_t host_row_pitch,
                            size_t host_slice_pitch);
};

template < class T >
C_host_memory_block<T>::C_host_memory_block()
{
  pData = NULL;
  element_size = sizeof (T);
  num_elements = 0;
}

template < class T>
C_host_memory_block<T>::~C_host_memory_block()
{
  if (pData!=NULL) delete pData;
  num_elements = 0;
}

template < class T >
void C_host_memory_block<T>::Init(int num_elem, T & value)
{
  if (pData!=NULL) delete pData;
  pData= new T [num_elem];
  for (int i=0; i<num_elem; i++)
    pData[i] = value;

  num_elements= num_elem;
}

template < class T >
void C_host_memory_block<T>::Init(int num_elem)
{
  if (pData!=NULL) delete pData;
  pData = new T [num_elem];
  for (int i=0; i<num_elem; i++)
    pData[i]= (T) i;

  num_elements = num_elem;

}
template < class T >
void  C_host_memory_block<T>::Set_to_zero()
{
  T v = 0;
  Set_to(v);
}

template < class T >
void  C_host_memory_block<T>::Set_to(T &val)
{
  for (int i=0; i<num_elements; i++)
    pData[i] = val;
}

template < class T >
bool C_host_memory_block<T>::Equal_to(T &val)
{
  int count = 0;

  for (int i=0; i<num_elements; i++) {
    if (pData[i] == val)
      count++;
  }

  return (count== num_elements);
}

template < class T >
bool C_host_memory_block<T>::Equal(C_host_memory_block < T > & another)
{
  int count = 0;

  for (int i=0; i<num_elements; i++) {
    if (pData[i] == another.pData[i])
      count++;
  }

  return (count== num_elements);
}

template < class T >
bool C_host_memory_block<T>::Equal(T *pIn_Data, int Innum_elements)
{
  if (this->num_elements!= Innum_elements)
    return false;

  int count = 0;

  for (int i=0; i<num_elements ; i++ ) {
    if (pData[i] == pIn_Data[i])
      count++;
  }

  return ( count== num_elements);
}

template < class T >
size_t C_host_memory_block<T>::Count(T &val)
{
  size_t count = 0;
  for (int i=0; i<num_elements; i++) {
    if (pData[i] == val)
      count++;
  }

  return count;
}

template < class T >
bool C_host_memory_block<T>::Equal_rect(C_host_memory_block < T > & another,
                                        size_t  * soffset,
                                        size_t  * region,
                                        size_t host_row_pitch,
                                        size_t host_slice_pitch)
{
  size_t row_pitch   = host_row_pitch ? host_row_pitch : region[0];
  size_t slice_pitch = host_slice_pitch ? host_row_pitch : region[1];

  size_t count = 0;

  size_t total = region[0] * region[1] * region[2];

  size_t x, y, z;
  size_t orig = (size_t)(soffset[0] + row_pitch*soffset[1] + slice_pitch * soffset[2]);
  for (z=0; z<region[2]; z++)
    for (y=0; y<region[1]; y++)
      for (x=0; x<region[0]; x++)
      {
        int p1 = (int)(x + row_pitch*y + slice_pitch* z + orig);
        if (pData[p1] == another.pData[p1])
          count++;
      }

  return (count == total);
}

template < class T >
bool C_host_memory_block<T>::Equal_rect_from_orig(C_host_memory_block < T > & another,
                                                  size_t * soffset,
                                                  size_t * region,
                                                  size_t host_row_pitch,
                                                  size_t host_slice_pitch)
{
  size_t row_pitch   = host_row_pitch ? host_row_pitch : region[0];
  size_t slice_pitch = host_slice_pitch ? host_row_pitch : region[1];

  size_t count = 0;

  size_t total = region[0] * region[1] * region[2];

  size_t x, y, z;
  size_t orig = soffset[0] + row_pitch * soffset[1] + slice_pitch * soffset[2];
  for (z=0; z<region[2]; z++)
    for (y=0; y<region[1]; y++)
      for (x=0; x<region[0]; x++)
      {
        size_t p1 = x + (row_pitch*y) + (slice_pitch*z);
        size_t p2 = p1 + orig;
        if (pData[p2] == another.pData[p1])
          count++;
      }

  return (count == total);
}

template < class T >
bool C_host_memory_block<T>::Equal_rect_from_orig(T* another_pdata,
                                                  size_t * soffset,
                                                  size_t * region,
                                                  size_t host_row_pitch,
                                                  size_t host_slice_pitch)
{
  size_t row_pitch   = host_row_pitch ? host_row_pitch : region[0];
  size_t slice_pitch = host_slice_pitch ? host_row_pitch : region[1];

  size_t count = 0;

  size_t total = region[0] * region[1] * region[2];

  size_t x, y, z;
  size_t orig = soffset[0] + row_pitch*soffset[1] + slice_pitch * soffset[2];
  for (z=0; z<region[2]; z++)
    for (y=0; y<region[1]; y++)
      for (x=0; x<region[0]; x++)
      {
        size_t p1 = x + (row_pitch * y) + (slice_pitch * z);
        size_t p2 = p1 + orig;
        if (pData[p2] == another_pdata[p1])
          count++;
      }

  return (count == total);
}

#endif