Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / system / util / include / blaze-data.h

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: blaze-data.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 ============================================
*/
#ifndef _BLAZE_DATA_H_
#define _BLAZE_DATA_H_

#pragma ident "@(#)1.1	09/19/03	blaze-data.h"

#include <thread.h>

template <class T> class List1Node
{
    T          data;
    List1Node* next;

public:

///////////////////////////////////////

    static List1Node* CreateInstance (const char *from)
    {
        List1Node * p = (List1Node*) calloc (1, sizeof(List1Node));
        if (p == NULL) {
	    if (from) {
	        fprintf (stderr, "<%s>: unable to allocate %d bytes \n",
		         from, sizeof(List1Node));
            }
	    else {
	        fprintf (stderr, "<LIST1>: unable to allocate %d bytes \n",
		         sizeof(List1Node));
            }
	    return NULL;
        }
        return p;
    }

///////////////////////////////////////

    static void AddTailProtected (List1Node **head, List1Node **tail, List1Node *instance, mutex_t *lock)
      {

	  List1Node *ph;
	  List1Node *pt;

	  mutex_lock(lock);

	  ph = *head;
	  pt = *tail;

          if (ph == NULL) {
	      *head = *tail = instance;
          }
	  else {
	      pt->next = instance;
              *tail    = instance;
          }

	  mutex_unlock(lock);
      }

///////////////////////////////////////

    static void AddTail (List1Node **head, List1Node **tail, List1Node *instance)
      {
	  List1Node *ph = *head;
	  List1Node *pt = *tail;

          if (ph == NULL) {
	      *head = *tail = instance;
          }
	  else {
	      pt->next = instance;
              *tail    = instance;
          }
      }
	static void AddTail (List1Node **head, List1Node *instance)
      {
	  List1Node *ph = *head;

          if (ph == NULL) {
	      *head = instance;
          }
	  else {
		List1Node * tail = *head;
		while(tail->next)
			tail = tail->next;

	      	tail->next = instance;
		instance->next = 0;
          }
      }
///////////////////////////////////////

    static void AddHeadProtected (List1Node **head, List1Node *instance, mutex_t *lock )
      {
	  List1Node *ph;

	  mutex_lock(lock);

	  ph = *head;

	  if (ph == NULL) {
	      *head = instance;
	  }
	  else {
	      instance->next = *head;
	      *head = instance;
	  }

	  mutex_unlock(lock);
      }

///////////////////////////////////////

    static void AddHead (List1Node **head, List1Node *instance)
      {
	  List1Node *ph = *head;
	  if (ph == NULL) {
	      *head = instance;
	  }
	  else {
	      instance->next = *head;
	      *head = instance;
	  }
      }


///////////////////////////////////////

    static void DeleteHead (List1Node **head)
      {
	  List1Node *ph = *head;
	  if (ph == NULL) {
	      return;
	  }
	  else {
	      *head = ph->next;
	       delete ph;
	  }
      }

///////////////////////////////////////

    static List1Node* GetHeadProtected (List1Node **head, mutex_t *lock)
      {
	  List1Node *ph;

	  mutex_lock(lock);
          ph = *head;

	  if (ph != NULL) {
	      *head = ph->next;
	  }
	  mutex_unlock(lock);
	  return ph;
      }

///////////////////////////////////////

    static List1Node* GetHead (List1Node **head)
      {
	  List1Node *ph = *head;
	  if (ph != NULL) {
	      *head = ph->next;
	  }
	  return ph;
      }
 
///////////////////////////////////////

    static void DeleteNode (List1Node **head,  List1Node *prv)
      {
	  if (prv == NULL) {
              List1Node *pinstance = (*head);
              (*head) = pinstance->next;
              delete pinstance;
	      return;
          }
	  else {
             List1Node *pinstance = prv->next;
	     prv->next = pinstance->next;
	     delete pinstance;
          }
      }

///////////////////////////////////////

    T*  GetData () 
    {
        return &data;
    }

///////////////////////////////////////

    List1Node *Next ()
    {
        return next;
    }    

///////////////////////////////////////

    List1Node **GetNext ()
    {
	return &next;
    }

///////////////////////////////////////

    static void LinktoTail (List1Node *tail, List1Node *head)
    {
     	tail->next = head;
    }

};

#endif  // _BLAZE_DATA_H_