Version 1.1.0
-------------

  * When making an advocate chain, you no longer create an "rktask" as
    the last link, instead you make a "real-time-task"...  Sorry for
    the inconvenience.  As an example, the following commands were
    used in previous versions to create an advocate chain:

    $ cbhey file://cb.ior create rktask with name rt1 > rkt.ior
    $ cbhey file://delegates.ior create real-time-task-delegate > t1.ior
    ...

    While the following commands should be used in the current
    version:

    $ cbhey file://cb.ior create real-time-task with name rt1 > rtt.ior
    $ cbhey file://delegates.ior create real-time-task-delegate > t1.ior
    ...

  * The advocate interface has changed so that the task's period is
    passed as a parameter and the actual reservation is returned.
    Room for expansion was also added through a parameter that takes a
    sequence of name/value pairs, although it is currently unused.
    Adapting to the new interface is relatively straightforward:

    For the application developer: The ReportCPU method now accepts a
    CPUReserve structure which contains the requested period and
    compute time.

    Here is an example of the old way:

	getrusage(RUSAGE_SELF, &ru);
	status = ru2micros(&ru) - ru2micros(&ru_last);
	myAdvocate->ReportCPU(myAdvocate.in(),
			      status,
			      status);

    And the new way:

	Broker::KeyedReportParameters krp;

	getrusage(RUSAGE_SELF, &ru);
	status.Period = myPeriod;
	status.Compute = ru2micros(&ru) - ru2micros(&ru_last);
	myAdvocate->ReportCPU(status, status, krp);

    For the advocate developer: Instead of calling ReportCPU on the
    next advocate in the chain, the PassCPU method is called.  So, any
    adaptation should be done in this method.

    Here is an example of the old way:

	void DoubleAdvocate::ReportCPU(Broker::RealTimeTask_ptr rtt,
				       CORBA::ULong status,
				       CORBA::ULong advice)
		throw (CORBA::SystemException)
	{
		this->RealTimeTaskDelegateImpl::ReportCPU(rtt,
							  status,
							  advice * 2);
	}

    And the new way:

	Broker::CPUReserve
	DoubleAdvocate::PassCPU(Broker::RealTimeTask_ptr rtt,
				const Broker::CPUReserve &status,
				const Broker::CPUReserve &advice,
				const Broker::KeyedReportParameters &krp)
		throw (CORBA::SystemException)
	{
		Broker::CPUReserve new_advice = advice;

		new_advice.Compute *= 2;
		return this->RealTimeTaskDelegateImpl::ReportCPU(rtt,
								 status,
								 new_advice,
								 krp);
	}

    Consequently, the cbhey(1) interface for the "report-cpu" property
    has also changed.  Instead of accepting "status" and "advice"
    parameters it requires "status.period", "status.compute",
    "advice.period", and "advice.compute".

  * There might still be problems if an "important" broker object
    becomes unreachable at an inconvenient time.

  * The rk_stub simulator is still a little flaky, it can get confused
    about which direction time is supposed to flow.

  * The Broker's CORBA objects are still not deletable.