WebSVN - shark - Blame - Rev 1689 - /shark/trunk/include/kernel/iqueue.h

Rev	Author	Line No.	Line
29	pj	1	/*
		2	* Project: S.Ha.R.K.
		3	*
		4	* Coordinators:
		5	* Giorgio Buttazzo <giorgio@sssup.it>
		6	* Paolo Gai <pj@gandalf.sssup.it>
		7	*
		8	* Authors :
		9	* Paolo Gai <pj@gandalf.sssup.it>
		10	* (see the web pages for full authors list)
		11	*
		12	* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
		13	*
		14	* http://www.sssup.it
		15	* http://retis.sssup.it
		16	* http://shark.sssup.it
		17	*/
		18
		19	/*
		20	------------
79	pj	21	CVS : $Id: iqueue.h,v 1.2 2003-03-13 13:36:28 pj Exp $
29	pj	22
		23	File: $File$
79	pj	24	Revision: $Revision: 1.2 $
		25	Last update: $Date: 2003-03-13 13:36:28 $
29	pj	26	------------
		27
		28	*/
		29
		30	/*
		31	* Copyright (C) 2002 Paolo Gai
		32	*
		33	* This program is free software; you can redistribute it and/or modify
		34	* it under the terms of the GNU General Public License as published by
		35	* the Free Software Foundation; either version 2 of the License, or
		36	* (at your option) any later version.
		37	*
		38	* This program is distributed in the hope that it will be useful,
		39	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		40	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		41	* GNU General Public License for more details.
		42	*
		43	* You should have received a copy of the GNU General Public License
		44	* along with this program; if not, write to the Free Software
		45	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		46	*
		47	*/
		48
		49
		50	/*
		51	IQUEUEs
		52
		53	This file contains functions that helps to manage task queues.
		54
		55	These functions are different from the functions that manages the
		56	QUEUE and QQUEUE types. In particular, these functions no more relies
		57	on the prev & next fields of the task descriptor. In that way, tasks
		58	can be inserted in more than one queue at a time.
		59
		60	Basically, an IQUEUE has an "I"nternal prev/next structure, that may
		61	be shared between one or more queue. Of course, the user MUST
		62	guarantee that the same task will not be inserted in two IQUEUEs that
		63	share the same prev/next buffer.
		64
		65	The queue insertion is made by the following functions:
		66	iq_insert -> insertion based on the priority field.
		67	iq_timespec_insert -> same as above but use the timespec_priority field
		68	iq_insertfirst -> insert in the first position of the queue
		69	*/
		70
		71	#include <ll/ll.h>
		72	#include <kernel/const.h>
		73	#include <kernel/types.h>
		74
		75	#ifndef __KERNEL_IQUEUE_H__
		76	#define __KERNEL_IQUEUE_H__
		77
1689	fabio	78	#include <arch/sys/cdefs.h>
79	pj	79
		80	__BEGIN_DECLS
		81
29	pj	82	#define IQUEUE_NO_PRIORITY 1
		83	#define IQUEUE_NO_TIMESPEC 2
		84
		85	struct IQUEUE_shared {
		86	PID prev[MAX_PROC];
		87	PID next[MAX_PROC];
		88	struct timespec *timespec_priority;
		89	DWORD *priority;
		90	};
		91
		92	typedef struct {
		93	PID first;
		94	PID last;
		95	struct IQUEUE_shared *s;
		96	} IQUEUE;
		97
		98
		99
		100	/* Internal queue initialization:
		101
		102	share = &x -> the internal data structure of the IQUEUE x is used
		103	to enqueue the tasks.
		104
		105	share = NULL -> an internal data structure to handle prev/next
		106	pairs is dynamically allocated (The amount of
		107	memory that is allocated can be reduced using the
		108	flags).
		109
		110	flags can be used to reduce the memory usage of an IQUEUE when share=NULL:
		111	IQUEUE_NO_PRIORITY -> the iqueue do not provide internally a priority field
		112	IQUEUE_NO_TIMESPEC -> the iqueue do not provide internally a timespec field
		113
		114	- note that, if these flags are used, the corresponding insert
		115	functions will not work!
		116	- the default value for the flags is, of course, 0
		117	*/
		118	void iq_init (IQUEUE q, IQUEUE share, int flags);
		119
		120	/* Queue insert functions:
		121
		122	- inserts a p into the q. p must not be already inserted into q.
		123	- four versions of the function;
		124	- iq_priority_insert -> ordered insertion using the priority field
		125	- iq_timespec_insert -> ordered insertion using the timespec field
		126	- iq_insertfirst -> insert at the first position of the queue
		127	- iq_insertlast -> insert at the last position of the queue
		128	*/
		129	void iq_priority_insert (PID p, IQUEUE *q);
		130	void iq_timespec_insert (PID p, IQUEUE *q);
		131	void iq_insertfirst (PID p, IQUEUE *q);
		132	void iq_insertlast (PID p, IQUEUE *q);
		133
		134	/* Queue extract functions:
		135
		136	- extracts a task p from the queue q.
		137	- three versions of the function;
		138	- iq_extract -> extracts given a task p
		139	(that must be inserted in the queue)
		140
		141	- iq_getfirst -> extracts the first task in the queue,
		142	NIL if the queue is empty
		143
		144	- iq_getlast -> extracts the last task in the queue,
		145	NIL if the queue is empty
		146
		147	*/
		148	void iq_extract (PID p, IQUEUE *q);
		149	PID iq_getfirst ( IQUEUE *q);
		150	PID iq_getlast ( IQUEUE *q);
		151
		152
		153	/* Queue query functions:
		154
		155	The first two functions return the first and the last task in the queue,
		156	NIL if the queue is empty.
		157
		158	The second two functions can be used to get/set the priority or the
		159	timespec field used when queuing.
		160	*/
		161	static __inline__ PID iq_query_first(IQUEUE *q)
		162	{
		163	return q->first;
		164	}
		165
		166	static __inline__ PID iq_query_last(IQUEUE *q)
		167	{
		168	return q->last;
		169	}
		170
		171	static __inline__ struct timespec iq_query_timespec(PID p, IQUEUE q)
		172	{
		173	return &q->s->timespec_priority[p];
		174	}
		175
		176	static __inline__ DWORD iq_query_priority (PID p, IQUEUE q)
		177	{
		178	return &q->s->priority[p];
		179	}
		180
		181	/* Queue iterators */
		182
		183	/* sometimes it is useful to go through the list. For that reason
		184	You can use the following two functions... */
		185	static __inline__ PID iq_query_next (PID p, IQUEUE *q)
		186	{
		187	return q->s->next[p];
		188	}
		189
		190	static __inline__ PID iq_query_prev (PID p, IQUEUE *q)
		191	{
		192	return q->s->prev[p];
		193	}
		194
		195	/* Queue test functions */
		196	static __inline__ int iq_isempty (IQUEUE *q)
		197	{
		198	return q->first == NIL;
		199	}
		200
79	pj	201	__END_DECLS
29	pj	202	#endif

Subversion Repositories shark

(root)/shark/trunk/include/kernel/iqueue.h @ 120 - Rev 1689