Attachment #281207 for bug #472046

View | Details | Raw Unified | Return to bug 472046
Collapse All | Expand All




#define XSyncCAAllTrigger \
    (XSyncCACounter | XSyncCAValueType | XSyncCAValue | XSyncCATestType)

static void SyncComputeBracketValues(SyncCounter *);

static void SyncInitServerTime(void);


    }

    if (IsSystemCounter(pTrigger->pCounter))
	SyncComputeBracketValues(pTrigger->pCounter);
}



    pTrigger->pCounter->pTriglist = pCur;

    if (IsSystemCounter(pTrigger->pCounter))
	SyncComputeBracketValues(pTrigger->pCounter);

    return Success;
}

    }
    else if (IsSystemCounter(pCounter))
    {
	SyncComputeBracketValues(pCounter);
    }

    return Success;

    for (ptl = pCounter->pTriglist; ptl; ptl = pnext)
    {
	pnext = ptl->next;
	if ((*ptl->pTrigger->CheckTrigger)(ptl->pTrigger, oldval)) {
	    (*ptl->pTrigger->TriggerFired)(ptl->pTrigger);
	}
    }

    if (IsSystemCounter(pCounter))
    {
	SyncComputeBracketValues(pCounter);
    }
}


}

static void
SyncComputeBracketValues(SyncCounter *pCounter)
{
    SyncTriggerList *pCur;
    SyncTrigger *pTrigger;

    if (ct == XSyncCounterNeverChanges)
	return;

    XSyncMaxValue(&psci->bracket_greater);
    XSyncMinValue(&psci->bracket_less);

	XSyncMinValue(&psci->bracket_less);
    }

    for (pCur = pCounter->pTriglist; pCur; pCur = pCur->next)
    {
	pTrigger = pCur->pTrigger;

        if ( ( (pTrigger->test_type == XSyncPositiveComparison)
	       && ( XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value)
		    || (ct != XSyncCounterNeverIncreases
			&& XSyncValueLessThan(pCounter->value, pTrigger->test_value))
		    )
	       )
	     || ((pTrigger->test_type == XSyncPositiveTransition)
		 && ( ( ct != XSyncCounterNeverDecreases
			&& XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value))
		      || ( ct != XSyncCounterNeverIncreases
			  && XSyncValueLessThan(pCounter->value, pTrigger->test_value))
		      )
		 ct != XSyncCounterNeverDecreases)
	{
	    if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) &&
		XSyncValueGreaterThan(pTrigger->test_value,
				      psci->bracket_less))
	    {
		psci->bracket_less = pTrigger->test_value;
		pnewltval = &psci->bracket_less;
	    }
	}
	else if ( (pTrigger->test_type == XSyncPositiveTransition &&
		   ct != XSyncCounterNeverIncreases)
		 ||
		 (pTrigger->test_type == XSyncNegativeTransition &&
		  ct != XSyncCounterNeverDecreases)
		 )
	     ) {
	      if (XSyncValueLessThan(pTrigger->test_value,
				     psci->bracket_greater)) {
		  psci->bracket_greater = pTrigger->test_value;
		  pnewgtval = &psci->bracket_greater;
		{
		    psci->bracket_greater = pTrigger->test_value;
		    pnewgtval = &psci->bracket_greater;
		}
		else
		if (XSyncValueGreaterThan(pTrigger->test_value,
					  psci->bracket_less))
		{
		    psci->bracket_less = pTrigger->test_value;
		    pnewltval = &psci->bracket_less;
		}
	} else if ( ( (pTrigger->test_type == XSyncNegativeComparison)
		      && ( XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value)
			   || (ct != XSyncCounterNeverDecreases
			       && XSyncValueGreaterThan(pCounter->value, pTrigger->test_value))
			   )
		      )
		    || ((pTrigger->test_type == XSyncNegativeTransition)
			&& ( ( ct != XSyncCounterNeverDecreases
			       && XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value))
			     || ( ct != XSyncCounterNeverIncreases
				  && XSyncValueLessThan(pCounter->value, pTrigger->test_value))
			    )
			)
		    ) {
	    if (XSyncValueGreaterThan(pTrigger->test_value,
				      psci->bracket_less)) {
		psci->bracket_less = pTrigger->test_value;
		pnewltval = &psci->bracket_less;
	    }
	}
    } /* end for each trigger */

}

static void
IdleTimeBlockHandler (pointer env,
                      struct timeval **wt,
                      pointer LastSelectMask)
{
  XSyncValue idle, old_idle;
  SyncTriggerList *list = IdleTimeCounter->pTriglist;
  SyncTrigger *trig;
  unsigned long timeout = -1;
  XSyncValue value;
  Bool overflow;
 

    if (!pIdleTimeValueLess && !pIdleTimeValueGreater)
	return;

	 * want level or edge trigger.  Check the trigger list against the
	 * current idle time, and if any succeed, bomb out of select()
	 * immediately so we can reschedule.
	 * NOTE: we need to check trigger because the idle timer can go
	 * both ways (XSyncCounterUnrestricted) so that we need to set
	 * pIdleTimeValueLess in ComputeBracketValues() in the edge
	 * triggered case even if the idle timer is already less.
	 */
        for (list = IdleTimeCounter->pTriglist; list; list = list->next) {
	for (list = IdleTimeCounter->pTriglist; list; list = list->next) {
	    trig = list->pTrigger;
	    if (trig->CheckTrigger(trig, old_idle)) {
	        AdjustWaitForDelay(wt, 0);
		IdleTimeCounter->value = old_idle; /* pop */
		return;
	    }
	}
    }
    if (pIdleTimeValueGreater)
    {
      /*
       * There's a threshold in the positive direction.
       * If we've been idle more than it, and someone wants to know about
       * that level-triggered, schedule an immediate wakeup.
       * NOTE: we need to check trigger because the idle timer can go
       * both ways (XSyncCounterUnrestricted) so that we need to set
       * pIdleTimeValueGreater in ComputeBracketValues() in the edge
       * triggered case even if the idle timer is already greater.
       */
	    XSyncValue value;
	    Bool overflow;

	if (XSyncValueGreaterOrEqual (idle, *pIdleTimeValueGreater)) {
	                        idle, &overflow);
	    timeout = min(timeout, XSyncValueLow32 (value));
	} else {
	    for (list = IdleTimeCounter->pTriglist; list; list = list->next) {
	        trig = list->pTrigger;
		if (trig->CheckTrigger(trig, old_idle)) {
		    AdjustWaitForDelay (wt, 0);
		    IdleTimeCounter->value = old_idle; /* pop */
		    return;
		}
	    }
	}

	AdjustWaitForDelay (wt, timeout);
    }

    /*
     * If we don't have to wake up immediately we schedule a wakeup for the
     * next time a trigger expires.
     */
    for (list = IdleTimeCounter->pTriglist; list; list = list->next) {
        trig = list->pTrigger;
	if (XSyncValueLessThan (idle, trig->test_value)) {
	    XSyncValueSubtract (&value, trig->test_value,
				idle, &overflow);
	    timeout = min(timeout,XSyncValueLow32 (value));
	}
    }
    AdjustWaitForDelay (wt, timeout);
    IdleTimeCounter->value = old_idle; /* pop */
}

- 

Return to bug 472046

Lines 97-103 static SyncCounter **SysCounterList = NULL; Link Here

(-)a/Xext/sync.c (-86 / +94 lines)
97	#define XSyncCAAllTrigger \	97	#define XSyncCAAllTrigger \
98	(XSyncCACounter \| XSyncCAValueType \| XSyncCAValue \| XSyncCATestType)	98	(XSyncCACounter \| XSyncCAValueType \| XSyncCAValue \| XSyncCATestType)
99		99
100	static void SyncComputeBracketValues(SyncCounter *, Bool);	100	static void SyncComputeBracketValues(SyncCounter *);
101		101
102	static void SyncInitServerTime(void);	102	static void SyncInitServerTime(void);
103		103
Lines 170-176 SyncDeleteTriggerFromCounter(SyncTrigger *pTrigger) Link Here
170	}	170	}
171		171
172	if (IsSystemCounter(pTrigger->pCounter))	172	if (IsSystemCounter(pTrigger->pCounter))
173	SyncComputeBracketValues(pTrigger->pCounter, /startOver/ TRUE);	173	SyncComputeBracketValues(pTrigger->pCounter);
174	}	174	}
175		175
176		176
Lines 197-203 SyncAddTriggerToCounter(SyncTrigger *pTrigger) Link Here
197	pTrigger->pCounter->pTriglist = pCur;	197	pTrigger->pCounter->pTriglist = pCur;
198		198
199	if (IsSystemCounter(pTrigger->pCounter))	199	if (IsSystemCounter(pTrigger->pCounter))
200	SyncComputeBracketValues(pTrigger->pCounter, /startOver/ TRUE);	200	SyncComputeBracketValues(pTrigger->pCounter);
201		201
202	return Success;	202	return Success;
203	}	203	}
Lines 354-360 SyncInitTrigger(ClientPtr client, SyncTrigger *pTrigger, XSyncCounter counter, Link Here
354	}	354	}
355	else if (IsSystemCounter(pCounter))	355	else if (IsSystemCounter(pCounter))
356	{	356	{
357	SyncComputeBracketValues(pCounter, /startOver/ TRUE);	357	SyncComputeBracketValues(pCounter);
358	}	358	}
359		359
360	return Success;	360	return Success;
Lines 643-655 SyncChangeCounter(SyncCounter *pCounter, CARD64 newval) Link Here
643	for (ptl = pCounter->pTriglist; ptl; ptl = pnext)	643	for (ptl = pCounter->pTriglist; ptl; ptl = pnext)
644	{	644	{
645	pnext = ptl->next;	645	pnext = ptl->next;
646	if ((*ptl->pTrigger->CheckTrigger)(ptl->pTrigger, oldval))	646	if ((*ptl->pTrigger->CheckTrigger)(ptl->pTrigger, oldval)) {
647	(*ptl->pTrigger->TriggerFired)(ptl->pTrigger);	647	(*ptl->pTrigger->TriggerFired)(ptl->pTrigger);
		648	}
648	}	649	}
649		650
650	if (IsSystemCounter(pCounter))	651	if (IsSystemCounter(pCounter))
651	{	652	{
652	SyncComputeBracketValues(pCounter, /* startOver */ FALSE);	653	SyncComputeBracketValues(pCounter);
653	}	654	}
654	}	655	}
655		656
Lines 916-922 SyncDestroySystemCounter(pointer pSysCounter) Link Here
916	}	917	}
917		918
918	static void	919	static void
919	SyncComputeBracketValues(SyncCounter *pCounter, Bool startOver)	920	SyncComputeBracketValues(SyncCounter *pCounter)
920	{	921	{
921	SyncTriggerList *pCur;	922	SyncTriggerList *pCur;
922	SyncTrigger *pTrigger;	923	SyncTrigger *pTrigger;
Lines 933-992 SyncComputeBracketValues(SyncCounter *pCounter, Bool startOver) Link Here
933	if (ct == XSyncCounterNeverChanges)	934	if (ct == XSyncCounterNeverChanges)
934	return;	935	return;
935		936
936	if (startOver)	937	XSyncMaxValue(&psci->bracket_greater);
937	{	938	XSyncMinValue(&psci->bracket_less);
938	XSyncMaxValue(&psci->bracket_greater);	939
939	XSyncMinValue(&psci->bracket_less);
940	}
941		940
942	for (pCur = pCounter->pTriglist; pCur; pCur = pCur->next)	941	for (pCur = pCounter->pTriglist; pCur; pCur = pCur->next)
943	{	942	{
944	pTrigger = pCur->pTrigger;	943	pTrigger = pCur->pTrigger;
945		944
946	if (pTrigger->test_type == XSyncPositiveComparison &&	945	if ( ( (pTrigger->test_type == XSyncPositiveComparison)
947	ct != XSyncCounterNeverIncreases)	946	&& ( XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value)
948	{	947	\|\| (ct != XSyncCounterNeverIncreases
949	if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) &&	948	&& XSyncValueLessThan(pCounter->value, pTrigger->test_value))
950	XSyncValueLessThan(pTrigger->test_value,	949	)
951	psci->bracket_greater))	950	)
952	{	951	\|\| ((pTrigger->test_type == XSyncPositiveTransition)
953	psci->bracket_greater = pTrigger->test_value;	952	&& ( ( ct != XSyncCounterNeverDecreases
954	pnewgtval = &psci->bracket_greater;	953	&& XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value))
955	}	954	\|\| ( ct != XSyncCounterNeverIncreases
956	}	955	&& XSyncValueLessThan(pCounter->value, pTrigger->test_value))
957	else if (pTrigger->test_type == XSyncNegativeComparison &&	956	)
958	ct != XSyncCounterNeverDecreases)
959	{
960	if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) &&
961	XSyncValueGreaterThan(pTrigger->test_value,
962	psci->bracket_less))
963	{
964	psci->bracket_less = pTrigger->test_value;
965	pnewltval = &psci->bracket_less;
966	}
967	}
968	else if ( (pTrigger->test_type == XSyncPositiveTransition &&
969	ct != XSyncCounterNeverIncreases)
970	\|\|
971	(pTrigger->test_type == XSyncNegativeTransition &&
972	ct != XSyncCounterNeverDecreases)
973	)	957	)
974	{	958	) {
975	if (XSyncValueLessThan(pCounter->value, pTrigger->test_value))	959	if (XSyncValueLessThan(pTrigger->test_value,
976	{	960	psci->bracket_greater)) {
977	if (XSyncValueLessThan(pTrigger->test_value,	961	psci->bracket_greater = pTrigger->test_value;
978	psci->bracket_greater))	962	pnewgtval = &psci->bracket_greater;
979	{
980	psci->bracket_greater = pTrigger->test_value;
981	pnewgtval = &psci->bracket_greater;
982	}
983	else
984	if (XSyncValueGreaterThan(pTrigger->test_value,
985	psci->bracket_less))
986	{
987	psci->bracket_less = pTrigger->test_value;
988	pnewltval = &psci->bracket_less;
989	}	963	}
		964	} else if ( ( (pTrigger->test_type == XSyncNegativeComparison)
		965	&& ( XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value)
		966	\|\| (ct != XSyncCounterNeverDecreases
		967	&& XSyncValueGreaterThan(pCounter->value, pTrigger->test_value))
		968	)
		969	)
		970	\|\| ((pTrigger->test_type == XSyncNegativeTransition)
		971	&& ( ( ct != XSyncCounterNeverDecreases
		972	&& XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value))
		973	\|\| ( ct != XSyncCounterNeverIncreases
		974	&& XSyncValueLessThan(pCounter->value, pTrigger->test_value))
		975	)
		976	)
		977	) {
		978	if (XSyncValueGreaterThan(pTrigger->test_value,
		979	psci->bracket_less)) {
		980	psci->bracket_less = pTrigger->test_value;
		981	pnewltval = &psci->bracket_less;
990	}	982	}
991	}	983	}
992	} /* end for each trigger */	984	} /* end for each trigger */
Lines 2291-2301 IdleTimeQueryValue (pointer pCounter, CARD64 *pValue_return) Link Here
2291	}	2283	}
2292		2284
2293	static void	2285	static void
2294	IdleTimeBlockHandler(pointer env, struct timeval **wt, pointer LastSelectMask)	2286	IdleTimeBlockHandler (pointer env,
2295	{	2287	struct timeval **wt,
2296	XSyncValue idle, old_idle;	2288	pointer LastSelectMask)
2297	SyncTriggerList *list = IdleTimeCounter->pTriglist;	2289	{
2298	SyncTrigger *trig;	2290	XSyncValue idle, old_idle;
		2291	SyncTriggerList *list = IdleTimeCounter->pTriglist;
		2292	SyncTrigger *trig;
		2293	unsigned long timeout = -1;
		2294	XSyncValue value;
		2295	Bool overflow;
		2296
2299		2297
2300	if (!pIdleTimeValueLess && !pIdleTimeValueGreater)	2298	if (!pIdleTimeValueLess && !pIdleTimeValueGreater)
2301	return;	2299	return;
Lines 2313-2358 IdleTimeBlockHandler(pointer env, struct timeval **wt, pointer LastSelectMask) Link Here
2313	* want level or edge trigger. Check the trigger list against the	2311	* want level or edge trigger. Check the trigger list against the
2314	* current idle time, and if any succeed, bomb out of select()	2312	* current idle time, and if any succeed, bomb out of select()
2315	* immediately so we can reschedule.	2313	* immediately so we can reschedule.
		2314	* NOTE: we need to check trigger because the idle timer can go
		2315	* both ways (XSyncCounterUnrestricted) so that we need to set
		2316	* pIdleTimeValueLess in ComputeBracketValues() in the edge
		2317	* triggered case even if the idle timer is already less.
2316	*/	2318	*/
2317		2319	for (list = IdleTimeCounter->pTriglist; list; list = list->next) {
2318	for (list = IdleTimeCounter->pTriglist; list; list = list->next) {
2319	trig = list->pTrigger;	2320	trig = list->pTrigger;
2320	if (trig->CheckTrigger(trig, old_idle)) {	2321	if (trig->CheckTrigger(trig, old_idle)) {
2321	AdjustWaitForDelay(wt, 0);	2322	AdjustWaitForDelay(wt, 0);
2322	break;	2323	IdleTimeCounter->value = old_idle; /* pop */
		2324	return;
2323	}	2325	}
2324	}	2326	}
2325	}	2327	}
2326	else if (pIdleTimeValueGreater)	2328	if (pIdleTimeValueGreater)
2327	{	2329	{
2328	/*	2330	/*
2329	* There's a threshold in the positive direction. If we've been	2331	* There's a threshold in the positive direction.
2330	* idle less than it, schedule a wakeup for sometime in the future.	2332	* If we've been idle more than it, and someone wants to know about
2331	* If we've been idle more than it, and someone wants to know about	2333	* that level-triggered, schedule an immediate wakeup.
2332	* that level-triggered, schedule an immediate wakeup.	2334	* NOTE: we need to check trigger because the idle timer can go
2333	*/	2335	* both ways (XSyncCounterUnrestricted) so that we need to set
2334	unsigned long timeout = -1;	2336	* pIdleTimeValueGreater in ComputeBracketValues() in the edge
2335		2337	* triggered case even if the idle timer is already greater.
2336	if (XSyncValueLessThan (idle, *pIdleTimeValueGreater)) {	2338	*/
2337	XSyncValue value;
2338	Bool overflow;
2339		2339
2340	XSyncValueSubtract (&value, *pIdleTimeValueGreater,	2340	if (XSyncValueGreaterOrEqual (idle, *pIdleTimeValueGreater)) {
2341	idle, &overflow);
2342	timeout = min(timeout, XSyncValueLow32 (value));
2343	} else {
2344	for (list = IdleTimeCounter->pTriglist; list; list = list->next) {	2341	for (list = IdleTimeCounter->pTriglist; list; list = list->next) {
2345	trig = list->pTrigger;	2342	trig = list->pTrigger;
2346	if (trig->CheckTrigger(trig, old_idle)) {	2343	if (trig->CheckTrigger(trig, old_idle)) {
2347	timeout = min(timeout, 0);	2344	AdjustWaitForDelay (wt, 0);
2348	break;	2345	IdleTimeCounter->value = old_idle; /* pop */
		2346	return;
2349	}	2347	}
2350	}	2348	}
2351	}	2349	}
2352
2353	AdjustWaitForDelay (wt, timeout);
2354	}	2350	}
2355		2351
		2352	/*
		2353	* If we don't have to wake up immediately we schedule a wakeup for the
		2354	* next time a trigger expires.
		2355	*/
		2356	for (list = IdleTimeCounter->pTriglist; list; list = list->next) {
		2357	trig = list->pTrigger;
		2358	if (XSyncValueLessThan (idle, trig->test_value)) {
		2359	XSyncValueSubtract (&value, trig->test_value,
		2360	idle, &overflow);
		2361	timeout = min(timeout,XSyncValueLow32 (value));
		2362	}
		2363	}
		2364	AdjustWaitForDelay (wt, timeout);
2356	IdleTimeCounter->value = old_idle; /* pop */	2365	IdleTimeCounter->value = old_idle; /* pop */
2357	}	2366	}
2358		2367
2359	-