Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / rst / rstzip3 / rstzip_v3 / rz3_rst_array.h

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: rz3_rst_array.h
* Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
* 
* The above named program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License version 2 as published by the Free Software Foundation.
* 
* The above named program is distributed in the hope that it will be 
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* General Public License for more details.
* 
* You should have received a copy of the GNU General Public
* License along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
* 
* ========== Copyright Header End ============================================
*/
/* rz3_rst_array.h
 * incrementally-growing array of rst records
 */

#include <stdio.h>
#include <strings.h>
#include <sys/types.h>

#include "rstf/rstf.h"

struct rz3_rst_array {
  rz3_rst_array(int sz) {

    maxcount = sz;

    nlines = (maxcount + linesize - 1)/linesize;

    lines = new rstf_unionT * [nlines];
    int i;
    for (i=0; i<nlines; i++) {
      lines[i] = NULL;
    }
    count = 0;
  }

  bool Push(const rstf_unionT * rec) {
    if (count >= maxcount) return false;
    int lidx = (count / linesize);
    int offs = count % linesize;
    if (lines[lidx] == NULL) {
      assert(offs == 0);
      lines[lidx] = new rstf_unionT [linesize];
    }
    memcpy(&(lines[lidx][offs]), rec, sizeof(rstf_unionT));
    count++;
    return true;
  }

  bool Get(int idx, rstf_unionT * where) {
    if (idx >= count) {
      return false;
    }
    int lidx = idx / linesize;
    int offs = idx % linesize;
    memcpy(where, &(lines[lidx][offs]), sizeof(rstf_unionT));
    return true;
  }

  const rstf_unionT * GetPtr(int idx) {
    if (idx >= count) {
      return NULL;
    }
    int lidx = idx/linesize;
    int offs = idx % linesize;
    return &(lines[lidx][offs]);
  }

  int Count() {
    return count;
  }

  bool CopyFrom(rstf_unionT * membuf, int howmany) {
    if (howmany > maxcount) return false;
    count = howmany;
    int full_line_count = (count / linesize);
    int partial_line_size = (count % linesize);
    int i;
    int recs_copied = 0;
    for (i=0; i<full_line_count; i++) {
      lines[i] = new rstf_unionT [linesize];
      memcpy(lines[i], membuf+recs_copied, linesize*sizeof(rstf_unionT));
      recs_copied += linesize;
    }
    if (partial_line_size) {
      lines[i] = new rstf_unionT [linesize];
      memcpy(lines[i], membuf+recs_copied, partial_line_size*sizeof(rstf_unionT));
    }
    return true;
  } // CopyFrom()

  // membuf must accomodate <count> records. count is returned by the Count() function
  bool CopyTo(rstf_unionT * membuf) {
    int full_line_count = (count/linesize);
    int partial_line_size = (count % linesize);
    int recs_copied = 0;
    int i;
    for (i=0; i<full_line_count; i++) {
      memcpy(membuf+recs_copied, lines[i], linesize*sizeof(rstf_unionT));
      recs_copied += linesize;
    }
    if (partial_line_size) {
      memcpy(membuf+recs_copied, lines[i], partial_line_size * sizeof(rstf_unionT));
    }
    return true;
  }

  void clear() {
    count = 0;
  }

  ~rz3_rst_array() {
    int i;
    for (i=0; i<nlines; i++) {
      if (lines[i] != NULL) {
	delete [] lines[i];
      }
    }
    delete [] lines;
  }

  enum consts_e { linesize = 512 };
  int maxcount;
  int count;
  int nlines;
  rstf_unionT * *lines;
}; // rz3_rst_array