Changing the Scheduler in Java Integration pdf417 in Java Changing the Scheduler

Changing the Scheduler generate, create barcode pdf417 none with java projects ISO QR Code standard Today (2002) priority sched PDF417 for Java ulers are the norm for real-time systems. A periodic scheduler with a notion of deadlines and feasibility might be tacked on the side, but even that much diversion from straight priority scheduling would be unusual. The scheduler situation is actually even less real-time than that.

The RTSJ has taken criticism because its fairly strict definition of a fixed-priority preemptive scheduler is challenging for some "real-time operating systems," and very challenging for some operating systems that usually do not make claims about real-time performance. Given a goal of being implementable under every operating system or kernel that makes a reasonable claim of supporting real-time computing, the RTSJ requires as much as it can: a fixed-priority preemptive scheduler with 28 priorities (plus the 10 loosely defined priorities of the regular Java specification) and a periodic scheduling system that can be superimposed on that priority scheduler. If the RTSJ required a deadline scheduler, its implementation would require kernel work on any of the popular real-time platforms (such as VxWorks, OS-9, QNX, Neutrino, LynxOS, PSOS, and Linux).

Instead, the RTSJ has scheduler APIs that are designed to accommodate dynamic priority scheduling algorithms. It even makes. AM FL Y 123 Team-Fly an effort to anticipate sch eduling paradigms that are unlike anything known today. The goal was to let OS/JVM vendors build new schedulers and make them accessible through the RTSJ APIs. Unfortunately, the RTSJ does not attempt to expose the interfaces that would let a programmer create a new scheduler.

That is a job for someone with access to the internals of the JVM and the supporting system software. The JVM always starts with the default fixed-priority preemptive scheduler active, but any thread (subject to Java security restrictions) can change the scheduler. A special scheduler might be on the default class path, or you might know the full path and class name for the scheduler, but the general way to find a new scheduler is through the system properties, as shown in Example 12-18.

Example 12-18 Finding a scheduler through system properties. public static Scheduler fin tomcat pdf417 2d barcode dScheduler(String policy){ String key = "javax.realtime.scheduler.

" + policy; String className = System.getProperty(key); if(className == null) // No system property for this scheduling policy return null; Class schedClass; try { schedClass = Class.forName(className); if(schedClass == null) // The scheduler class was not found return null; else { // Get a reference for the scheduler"s // instance() method.

(with no parameters) Method instance = schedClass.getMethod("instance", null); return (Scheduler)instance.invoke(null, null); }.

The instance method in Sche duler is static, so it doesn"t need an object parameter, and it takes no args, so the parameters for instance.invoke are null, null. The instance method in Scheduler will return a reference to a singleton instance of that class.

The try clause around the code that (a) finds the Scheduler class, (b) finds the instance method in it, and (c) invokes the instance method can throw a large collection of exceptions. Most of them are various ways of saying that the class isn"t there, you cannot see it, or it is not the sort of class you expected. For all of those, return null.

The security exception is probably interesting to the caller, so the catch clause rethrows that.. } catch (ClassNotFoundExcep pdf417 for Java tion nF){ // Thrown by forName() return null; } catch (NoSuchMethodException nS) { // Thrown by getMethod. // This is a sign of a mal-formed Scheduler class return null;. } catch (SecurityException security) { // This is a runtime exception. // It is thrown by the security manager, perhaps // when it checked for our authority to load a // class. throw security; } catch (IllegalAccessException access){ // Thrown by forName method if the scheduler // class is not public, or by invoke() if the // method is inaccessible (which it should be.

) return null; } catch (IllegalArgumentException arg) { // Since we don"t pass arguments, and the // instance() method does not expect arguments // we should never get here. return null; } catch (InvocationTargetException target) { // Some exception was thrown by instance(). // That exception is wrapped by target.

// instance() doesn"t throw any checked exceptions // so we should never get here. return null; } }. After finding a scheduling PDF 417 for Java class, we need to tell a thread to place itself under the supervision of that scheduler, as in Example 12-19. If you happen to have a scheduler with the policy name LLaxity installed in your system, the code snippet in Example 12-19 does the following: 1. Uses the findScheduler method from Example 12-18 to find the class, loads it, and gets a reference to the singleton instance of the least laxity scheduler.

2. If the code found a least-laxity scheduler, it creates a thread with periodic parameters (which least laxity schedulers can use). 3.

Uses the setScheduler method on the real-time thread to change its scheduler from the system default to least laxity. 4. Starts the thread.

The above protocol changes the scheduler for a thread, and the static setDefaultScheduler method can change the default scheduler for all real-time threads created after the default is changed. Example 12-19 Changing Change the scheduler for a thread [6th line: scheduling. Scheduler scheduler = FindS cheduler.findScheduler("LLaxity"); if(scheduler == null){ System.out.

println("No least laxity scheduler was found"); } else { RealtimeThread rtt = new RealtimeThread( null, //Default sceduling Parameters new PeriodicParameters( null, // Begin running at start() new RelativeTime(250, 0),//Period is 1/4 sec new RelativeTime(25, 0),//Cost is 1/40 sec new RelativeTime(200, 0),//Deadline is 1/5 sec null, //No overrun handler null), //No miss handler null, //Default memory parameters null, //Default memory area. null, //Default processing PDF417 for Java group new Runnable (){//Logic public void run() { System.out.println("Running least laxity"); } }); rtt.

setScheduler(scheduler); rtt.start();. There are some unresolved i ssues about pluggable schedulers, and they will stay unresolved until an actual alternative scheduler is available. The new scheduler must document how it will interact with other schedulers. It might be able to coexist with the standard priority scheduler or with other schedulers, or it might be disrupted by any threads that are not under its control.

An alternate scheduler might be able to take control of a live thread, or it might insist on becoming the scheduler for a thread before it starts. The alternate scheduler might be as simple as a scheduler that subclasses the standard priority scheduler and adds feasibility analysis to a scheduler that provides promiscuous feasibility analysis. The final example in this chapter is a simple version of the preceding scheduler.

It is a class that extends the trivial admission control in the reference implementation"s scheduler to add very simple feasibility analysis. To keep the example simple, the scheduler in Example 12-20 naively assumes that the caller would never try to add a thread or async event handler more than once to feasibility analysis, would never change the attributes of a schedulable that was not already added, or would never remove a schedulable from feasibility analysis if it was not there. It is easy to write new Scheduler classes to provide different admission control policies, but remember that the scheduler does much more than admission control.

It has hidden functions, many of them probably implemented as part of the JVM or the underlying operating system. Example 12-20 avoids real scheduling by just extending an existing scheduler. The synchronization of the methods in the class that manipulates the utilization is important.

It keeps changes to the utilization instance variable atomic. It also locks the instance for the duration of the changeIfFeasable method. This prevents race conditions on manipulation of utilization.

Example 12-20 Alternate scheduler class. import javax.realtime.*; /* j2se PDF417 * * Extend an RTSJ default priority scheduler with * admission control/feasibility services.

*/ public class FPriorityScheduler extends PriorityScheduler{ private double utilization = 0; private final static String policy = "PriortySchedulerWithFeasibility"; private static FPriorityScheduler me = null; /** * The only constructor for this class is private. * To get an instance of FPriorityScheduler use the * instance method */ private FPriorityScheduler(){ super.instance(); }.

/** * Add a schedulable (th read or AEH) to the feasible set. * * Warning, this method will happily add the same thread to the * feasible set many times. * * Note, this class only tracks the total CPU consumption * of all registered schedulable entities.

* * @param s The schedulable (rt thread or AEH) to add to * the feasible set. */ protected synchronized void addToFeasibility(Schedulable s){ if(!check(s)) return; PeriodicParameters param = (PeriodicParameters) s.getReleaseParameters(); RelativeTime cost = param.

getCost(); if (cost == null) cost = param.getDeadline(); utilization += calcUtilization(cost, param.getPeriod()); } /** * Calculate the CPU utilization given cost and period.

* @param cost the cost of a schedulable * @param period the period of the schedulable * @return the CPU utilization for this schedulable */ private double calcUtilization(RelativeTime cost, RelativeTime period){ double costMicros = (cost.getMilliseconds() * 1000.0) + (cost.

getNanoseconds() / 1000.0); double periodMicros = (period.getMilliseconds() * 1000.

0) + (period.getNanoseconds() / 1000.0); return costMicros / periodMicros; } /** * Check a Schedulable"s eligibility for admission control * @param s The Schedulable to test * @returnTrue if the schedulable is eligible */ private boolean check(Schedulable s){ if(s.

getReleaseParameters() instanceof PeriodicParameters){ PeriodicParameters param = (PeriodicParameters) s.getReleaseParameters(); if(!positive(param.getPeriod())) throw new IllegalArgumentException("period <= 0"); if( param.

getCost() == null && param.getDeadline() == null) return false; return true; } else return false; } /** * Return the name of the policy this scheduler implements. *.

* @return The name of this servlet pdf417 policy * "Priority Scheduler with Feasibility" */ public java.lang.String getPolicyName(){ return policy; } /** * Return a reference to the singleton instance of this class.

* If the class has not yet been instanciated, construct it. * * @return A reference to an instance of class * FPriorityScheduler */ public static PriorityScheduler instance() { if(me == null) me = new FPriorityScheduler(); return me; } /** * Return true if the set of schedulables that have been through * addToFeasible, but not removeFromFeasible do not use more * than 100% of CPU time * * @return True if the load is feasible, false otherwise */ public boolean isFeasible(){ return utilization <= 1.0; } /** * Change the scheduling attributes of the specified * schedulable.

* * * WARNING: This method assumes that the schedulable entity is * already feasible * * @param schedulable A reference to a rt thread or AEH that * should be changed * @param release The release parameters that should be * tested for feasibility * @param memory The memory parameters that should be * tested for feasibility * @return true if the change is feasible, false otherwise */ public synchronized boolean changeIfFeasible( Schedulable schedulable, ReleaseParameters release, MemoryParameters memory){ RelativeTime cost; double oldUtil; double newUtil; if(!check(schedulable)) // Check schedulable"s attributes return false; // Don"t add ill-formed schedulables if(release instanceof PeriodicParameters){ PeriodicParameters param = (PeriodicParameters) schedulable.getReleaseParameters(); cost = param.getCost();.

if (cost == null) cost = pa ram.getDeadline(); oldUtil = calcUtilization(cost, param.getPeriod()); param = (PeriodicParameters)release; if(!positive(param.

getPeriod())) throw new IllegalArgumentException("period <= 0"); cost = param.getCost(); if(cost == null) cost = param.getDeadline(); newUtil = calcUtilization(cost, param.

getPeriod()); if(utilization + newUtil - oldUtil <= 1.0){ utilization += (newUtil - oldUtil); return true; } else return false; } else { // Not PeriodicParameters throw new IllegalArgumentException( "release must be periodic"); } } /** * Remove the specified schedulable entity from * feasibility analysis. * * WARNING: This method does not check that the schedulable is * current in the feasible set.

* * @param s A reference to a schedulable entity */ protected synchronized void removeFromFeasibility( Schedulable s){ if(!check(s)) return; PeriodicParameters param = (PeriodicParameters) s.getReleaseParameters(); RelativeTime cost = param.getCost(); if (cost == null) cost = param.

getDeadline(); utilization -= calcUtilization(cost, param.getPeriod()); } /** Test for relative time greater than 0 *@param t RelativeTime value *@return true iff time > 0 */ private boolean positive(RelativeTime t){ if(t.getMilliseconds() == 0) return t.

getNanoseconds() > 0; else return t.getMilliseconds() > 0; } /** main method to test this class */ static public void main(String [] args){ //**start** RealtimeThread rtt = new RealtimeThread( null, //Default scheduling Parameters new PeriodicParameters(. null, // Begin running at s pdf417 2d barcode for Java tart() new RelativeTime(250, 0), //Period is 1/4 sec new RelativeTime(25, 0), //Cost is 1/40 sec new RelativeTime(200, 0), //Deadline is 1/5 sec null, //No overrun handler null), //No miss handler null, //Default memory parameters null, //Default memory area null, //Default processing group new Runnable (){//Logic public void run() { System.out.println("Running " + RealtimeThread.

currentRealtimeThread(). getScheduler().getPolicyName()); } }); rtt.

setScheduler(FPriorityScheduler.instance()); rtt.start(); try{ rtt.

join(); } catch(Exception e) {} } }.
Copyright © . All rights reserved.