GF.Queuing - Revision history

Jan Schoonderbeek: promoted to maturity 2 + small layout improvement

2015-01-06T06:28:55Z

promoted to maturity 2 + small layout improvement

← Older revision		Revision as of 06:28, 6 January 2015
Line 1:		Line 1:
	{{Maturity\|0}}		{{Maturity\|2}}
	{{Pageheaderbox4GF		{{Pageheaderbox4GF
	\|name=Queuing		\|name=Queuing
Line 13:		Line 13:

	Examples of queuing policies are:		Examples of queuing policies are:
	* First in first out:		* First in first out:<br>This policy states that the job that has been waiting the longest is served first.
	This policy states that the job that has been waiting the longest is served first.		* Last in first out:<br>This policy states that the job that was added most recently will be served first.
	* Last in first out:		* Resource sharing:<br>Service capacity is shared equally over multiple jobs.
	This policy states that the job that was added most recently will be served first.		* Priority:<br>A job with an assigned priority that is higher than that of another job is served first. This ofcourse means a priority criterium must be available, e.g. based on metadata.
	* Resource sharing:		* Shortest job first:<br>The next job to be served is the one with the smallest size or shortest expected duration.
	Service capacity is shared equally over multiple jobs.
	* Priority:
	A job with an assigned priority that is higher than that of another job is served first. This ofcourse means a priority criterium must be available, e.g. based on metadata.
	* Shortest job first:
	The next job to be served is the one with the smallest size or shortest expected duration.
	* Pre-emptive shortest job first:		* Pre-emptive shortest job first:
	The next job to be served is the one with the smallest size or shortest expected duration; if a new job comes in with smaller size or expected duration than the remaining size/duration of the currently running job, the running job is interrupted.		The next job to be served is the one with the smallest size or shortest expected duration; if a new job comes in with smaller size or expected duration than the remaining size/duration of the currently running job, the running job is interrupted.

Mischa Frenk at 22:15, 2 January 2015

2015-01-02T22:15:41Z

← Older revision		Revision as of 22:15, 2 January 2015
Line 3:		Line 3:
	\|name=Queuing		\|name=Queuing
	\|WorkingArea=Network		\|WorkingArea=Network
	\|version=0.3		\|version=0.4
	\|owner=Mischa Frenk		\|owner=Mischa Frenk
	\|summary=Provides the ability to process traffic based various queuing policies.		\|summary=Provides the ability to process traffic based various queuing policies.
	}}		}}
	Function to optimise traffic or resource usage based on ~~various~~ queuing policies. Examples of queuing policies ~~can be~~:		This Function serves to optimise processing of traffic or resource usage, based on one or more queuing policies. A queuing policy formulates a decision on which job to perform next, where "job" can mean an action, processing task, data packet transfer et cetera. Queuing policies generally can occur in two different forms:
	* First in, first out~~<br>~~This policy states ~~that data elements are processed one at a time and~~ that the ~~data elements~~ that has been waiting the longest is served first.		* non-pre-emptive: in this form a job being processed cannot be interrupted; the queuing function simply decides on the next job in line;
	* Last in first out~~<br>~~This policy ~~also serves data elements one at a time, however~~ the ~~data element with the shortest waiting time~~ will be served first.		* pre-emptive: in this form an active job can be interrupted as soon as another non-active job takes precedence according to the queuing policy. The active job is deactivated (usually without losing the results of the processing thusfar), and the higher precedence job starts processing.
	* Resource sharing~~<br>~~Service capacity is shared equally.		To be able to prioritize jobs, Queuing must be paired with Caching, which then serves as the buffer for jobs that cannot be processed yet.
	* Priority~~<br>Data elements~~ with an assigned priority that is higher than that of another ~~data element~~ is served first. ~~Priority queues can~~ be ~~of two types~~, ~~non-pre-emptive (where a job in service cannot be interrupted) and pre-emptive (where a job in service can be interrupted by a higher priority job)~~. ~~No work is lost in either model~~.
	* Shortest job first~~<br>~~The next job to be served is the one with the smallest size		Examples of queuing policies are:
	* Pre-emptive shortest job first~~<br>~~The next job to be served is the one with the ~~original~~ smallest size		* First in first out:
	* Shortest remaining processing time<br>The next job ~~to serve is the one~~ with the ~~smallest~~ remaining ~~processing requirement~~.		This policy states that the job that has been waiting the longest is served first.
			* Last in first out:
			This policy states that the job that was added most recently will be served first.
			* Resource sharing:
			Service capacity is shared equally over multiple jobs.
			* Priority:
			A job with an assigned priority that is higher than that of another job is served first. This ofcourse means a priority criterium must be available, e.g. based on metadata.
			* Shortest job first:
			The next job to be served is the one with the smallest size or shortest expected duration.
			* Pre-emptive shortest job first:
			The next job to be served is the one with the smallest size or shortest expected duration; if a new job comes in with smaller size or expected duration than the remaining size/duration of the currently running job, the running job is interrupted.
	{{FunctionIcon		{{FunctionIcon
	\|image=Icon GF Queuing.png		\|image=Icon GF Queuing.png
	}}		}}
	{{Text Footer GF}}		{{Text Footer GF}}

Jan Schoonderbeek: icon added

2014-12-28T09:31:05Z

icon added

← Older revision		Revision as of 09:31, 28 December 2014
Line 7:		Line 7:
	\|summary=Provides the ability to process traffic based various queuing policies.		\|summary=Provides the ability to process traffic based various queuing policies.
	}}		}}
	Function to optimise traffic or resource usage based on various queuing policies. Examples of queuing policies can be:		Function to optimise traffic or resource usage based on various queuing policies. Examples of queuing policies can be:
			* First in, first out<br>This policy states that data elements are processed one at a time and that the data elements that has been waiting the longest is served first.
	* First in first out<br>This policy states that data elements are processed one at a time and that the data elements that has been waiting the longest is served first.
	* Last in first out<br>This policy also serves data elements one at a time, however the data element with the shortest waiting time will be served first.		* Last in first out<br>This policy also serves data elements one at a time, however the data element with the shortest waiting time will be served first.
	* Resource sharing<br>Service capacity is shared equally.		* Resource sharing<br>Service capacity is shared equally.
Line 17:		Line 16:
	* Shortest remaining processing time<br>The next job to serve is the one with the smallest remaining processing requirement.		* Shortest remaining processing time<br>The next job to serve is the one with the smallest remaining processing requirement.
	{{FunctionIcon		{{FunctionIcon
	\|image=Icon		\|image=Icon GF Queuing.png
	}}		}}
	{{Text Footer GF}}		{{Text Footer GF}}

Mischa Frenk at 15:24, 24 December 2014

2014-12-24T15:24:14Z

← Older revision		Revision as of 15:24, 24 December 2014
Line 3:		Line 3:
	\|name=Queuing		\|name=Queuing
	\|WorkingArea=Network		\|WorkingArea=Network
	\|version=0.2		\|version=0.3
	\|owner=Mischa Frenk		\|owner=Mischa Frenk
	\|summary=Provides the ability to process traffic based various ~~scheduling~~ policies.		\|summary=Provides the ability to process traffic based various queuing policies.
	}}		}}
	Function to optimise ~~resources~~ usage ~~or traffic~~ based on various ~~scheduling~~ policies. Examples of ~~scheduling~~ policies can be:		Function to optimise traffic or resource usage based on various queuing policies. Examples of queuing policies can be:

	* First in first out<br>This ~~principle~~ states that ~~customers~~ are ~~served~~ one at a time and that the ~~customer~~ that has been waiting the longest is served first.		* First in first out<br>This policy states that data elements are processed one at a time and that the data elements that has been waiting the longest is served first.
	* Last in first out<br>This ~~principle~~ also serves ~~customers~~ one at a time, however the ~~customer~~ with the shortest waiting time will be served first~~. Also known as a stack~~.		* Last in first out<br>This policy also serves data elements one at a time, however the data element with the shortest waiting time will be served first.
	* ~~Processor~~ sharing<br>Service capacity is shared equally ~~between customers~~.~~[16]~~		* Resource sharing<br>Service capacity is shared equally.
	* Priority<br>~~Customers~~ with ~~high~~ priority ~~are~~ served first. Priority queues can be of two types, non-pre-emptive (where a job in service cannot be interrupted) and pre-emptive (where a job in service can be interrupted by a higher priority job). No work is lost in either model.		* Priority<br>Data elements with an assigned priority that is higher than that of another data element is served first. Priority queues can be of two types, non-pre-emptive (where a job in service cannot be interrupted) and pre-emptive (where a job in service can be interrupted by a higher priority job). No work is lost in either model.
	* Shortest job first<br>The next job to be served is the one with the smallest size		* Shortest job first<br>The next job to be served is the one with the smallest size
	* Pre-emptive shortest job first<br>The next job to be served is the one with the original smallest size		* Pre-emptive shortest job first<br>The next job to be served is the one with the original smallest size

Jan Schoonderbeek at 13:53, 24 December 2014

2014-12-24T13:53:09Z

← Older revision		Revision as of 13:53, 24 December 2014
Line 9:		Line 9:
	Function to optimise resources usage or traffic based on various scheduling policies. Examples of scheduling policies can be:		Function to optimise resources usage or traffic based on various scheduling policies. Examples of scheduling policies can be:

	* First in first out		* First in first out<br>This principle states that customers are served one at a time and that the customer that has been waiting the longest is served first.
	This principle states that customers are served one at a time and that the customer that has been waiting the longest is served first.		* Last in first out<br>This principle also serves customers one at a time, however the customer with the shortest waiting time will be served first. Also known as a stack.
	* Last in first out		* Processor sharing<br>Service capacity is shared equally between customers.[16]
	This principle also serves customers one at a time, however the customer with the shortest waiting time will be served first. Also known as a stack.		* Priority<br>Customers with high priority are served first. Priority queues can be of two types, non-pre-emptive (where a job in service cannot be interrupted) and pre-emptive (where a job in service can be interrupted by a higher priority job). No work is lost in either model.
	* Processor sharing		* Shortest job first<br>The next job to be served is the one with the smallest size
	Service capacity is shared equally between customers.[16]		* Pre-emptive shortest job first<br>The next job to be served is the one with the original smallest size
	* Priority		* Shortest remaining processing time<br>The next job to serve is the one with the smallest remaining processing requirement.
	Customers with high priority are served first. Priority queues can be of two types, non-pre-emptive (where a job in service cannot be interrupted) and pre-emptive (where a job in service can be interrupted by a higher priority job). No work is lost in either model.
	* Shortest job first
	The next job to be served is the one with the smallest size
	* Pre-emptive shortest job first
	The next job to be served is the one with the original smallest size
	* Shortest remaining processing time
	The next job to serve is the one with the smallest remaining processing requirement.
	{{FunctionIcon		{{FunctionIcon
	\|image=Icon		\|image=Icon
	}}		}}
	{{Text Footer GF}}		{{Text Footer GF}}

Jan Schoonderbeek: Jan Schoonderbeek moved page GF.Priority Queuing to GF.Queuing without leaving a redirect: rename

2014-12-24T13:51:43Z

Jan Schoonderbeek moved page GF.Priority Queuing to GF.Queuing without leaving a redirect: rename

← Older revision

Revision as of 13:51, 24 December 2014

Mischa Frenk at 13:50, 24 December 2014

2014-12-24T13:50:23Z

← Older revision		Revision as of 13:50, 24 December 2014
Line 1:		Line 1:
	{{Maturity\|0}}		{{Maturity\|0}}
	{{Pageheaderbox4GF		{{Pageheaderbox4GF
	\|name=~~Priority~~ Queuing		\|name=Queuing
	\|WorkingArea=Network		\|WorkingArea=Network
	\|version=0.1		\|version=0.2
	\|owner=Mischa Frenk		\|owner=Mischa Frenk
	\|summary=Provides the ability to process traffic based ~~on the assigned priority of data elements~~.		\|summary=Provides the ability to process traffic based various scheduling policies.
	}}		}}
	Function to optimise traffic ~~by allowing data elements~~ with high priority to be served ~~before a data elements~~ with ~~low priority~~.		Function to optimise resources usage or traffic based on various scheduling policies. Examples of scheduling policies can be:

			* First in first out
			This principle states that customers are served one at a time and that the customer that has been waiting the longest is served first.
			* Last in first out
			This principle also serves customers one at a time, however the customer with the shortest waiting time will be served first. Also known as a stack.
			* Processor sharing
			Service capacity is shared equally between customers.[16]
			* Priority
			Customers with high priority are served first. Priority queues can be of two types, non-pre-emptive (where a job in service cannot be interrupted) and pre-emptive (where a job in service can be interrupted by a higher priority job). No work is lost in either model.
			* Shortest job first
			The next job to be served is the one with the smallest size
			* Pre-emptive shortest job first
			The next job to be served is the one with the original smallest size
			* Shortest remaining processing time
			The next job to serve is the one with the smallest remaining processing requirement.
	{{FunctionIcon		{{FunctionIcon
	\|image=Icon		\|image=Icon
	}}		}}
	{{Text Footer GF}}		{{Text Footer GF}}

Mischa Frenk at 15:37, 19 December 2014

2014-12-19T15:37:38Z

← Older revision		Revision as of 15:37, 19 December 2014
Line 5:		Line 5:
	\|version=0.1		\|version=0.1
	\|owner=Mischa Frenk		\|owner=Mischa Frenk
	\|summary=Provides the ability to process traffic based on the assigned priority of ~~the~~ data elements.		\|summary=Provides the ability to process traffic based on the assigned priority of data elements.
	}}		}}
	Function to optimise traffic by allowing data elements with high priority to be served before a data elements with low priority.		Function to optimise traffic by allowing data elements with high priority to be served before a data elements with low priority.

Mischa Frenk at 15:37, 19 December 2014

2014-12-19T15:37:07Z

← Older revision		Revision as of 15:37, 19 December 2014
Line 5:		Line 5:
	\|version=0.1		\|version=0.1
	\|owner=Mischa Frenk		\|owner=Mischa Frenk
	\|summary=Provides the ability to ~~give different~~ priority ~~to different traffic~~		\|summary=Provides the ability to process traffic based on the assigned priority of the data elements.
	}}		}}
	Function to optimise traffic by allowing data elements with high priority to be served before a data elements with low priority.		Function to optimise traffic by allowing data elements with high priority to be served before a data elements with low priority.

Mischa Frenk: It is more and more common to make better usage of the network infrastructure and optimise traffic by allowing a data element with high priority to be served before a data element with low priority.

2014-12-19T15:32:18Z

It is more and more common to make better usage of the network infrastructure and optimise traffic by allowing a data element with high priority to be served before a data element with low priority.

New page

{{Maturity|0}}
{{Pageheaderbox4GF
|name=Priority Queuing
|WorkingArea=Network
|version=0.1
|owner=Mischa Frenk
|summary=Provides the ability to give different priority to different traffic
}}
Function to optimise traffic by allowing data elements with high priority to be served before a data elements with low priority.
{{FunctionIcon
|image=Icon
}}
{{Text Footer GF}}