andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Create SyncObject base type.

Browse Source 
SyncObject is now the base type for SyncCounter.
Data to be used by all sync types is stored in
the base object.  SyncCounter can be safely cast
to SyncObject, and a SyncObject can be cast to
the correct type based on SyncObject::type.

Signed-off-by: James Jones <jajones@nvidia.com>
Reviewed-by: Keith Packard <keithp@keithp.com>
This commit is contained in:
James Jones 2010-06-28 14:51:54 -07:00
parent 27593eea7e
commit 99daf419a3
2 changed files with 73 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
Xext/sync.c
View File

@ -89,7 +89,7 @@ static int SyncNumSystemCounters = 0;
static SyncCounter **SysCounterList = NULL; static SyncCounter **SysCounterList = NULL;
#define IsSystemCounter(pCounter) \ #define IsSystemCounter(pCounter) \
(pCounter && (pCounter->client == NULL)) (pCounter && (pCounter->sync.client == NULL))
/* these are all the alarm attributes that pertain to the alarm's trigger */ /* these are all the alarm attributes that pertain to the alarm's trigger */
#define XSyncCAAllTrigger \ #define XSyncCAAllTrigger \
@ -118,7 +118,7 @@ SyncDeleteTriggerFromCounter(SyncTrigger *pTrigger)
return; return;
pPrev = NULL; pPrev = NULL;
pCur = pTrigger->pCounter->pTriglist; pCur = pTrigger->pCounter->sync.pTriglist;
while (pCur) while (pCur)
{ {
@ -127,7 +127,7 @@ SyncDeleteTriggerFromCounter(SyncTrigger *pTrigger)
if (pPrev) if (pPrev)
pPrev->next = pCur->next; pPrev->next = pCur->next;
else else
pTrigger->pCounter->pTriglist = pCur->next; pTrigger->pCounter->sync.pTriglist = pCur->next;
free(pCur); free(pCur);
break; break;
@ -151,7 +151,7 @@ SyncAddTriggerToCounter(SyncTrigger *pTrigger)
return Success; return Success;
/* don't do anything if it's already there */ /* don't do anything if it's already there */
for (pCur = pTrigger->pCounter->pTriglist; pCur; pCur = pCur->next) for (pCur = pTrigger->pCounter->sync.pTriglist; pCur; pCur = pCur->next)
{ {
if (pCur->pTrigger == pTrigger) if (pCur->pTrigger == pTrigger)
return Success; return Success;
@ -161,8 +161,8 @@ SyncAddTriggerToCounter(SyncTrigger *pTrigger)
return BadAlloc; return BadAlloc;
pCur->pTrigger = pTrigger; pCur->pTrigger = pTrigger;
pCur->next = pTrigger->pCounter->pTriglist; pCur->next = pTrigger->pCounter->sync.pTriglist;
pTrigger->pCounter->pTriglist = pCur; pTrigger->pCounter->sync.pTriglist = pCur;
if (IsSystemCounter(pTrigger->pCounter)) if (IsSystemCounter(pTrigger->pCounter))
SyncComputeBracketValues(pTrigger->pCounter); SyncComputeBracketValues(pTrigger->pCounter);
@ -390,14 +390,14 @@ SyncSendCounterNotifyEvents(ClientPtr client, SyncAwait **ppAwait,
SyncTrigger *pTrigger = &(*ppAwait)->trigger; SyncTrigger *pTrigger = &(*ppAwait)->trigger;
pev->type = SyncEventBase + XSyncCounterNotify; pev->type = SyncEventBase + XSyncCounterNotify;
pev->kind = XSyncCounterNotify; pev->kind = XSyncCounterNotify;
pev->counter = pTrigger->pCounter->id; pev->counter = pTrigger->pCounter->sync.id;
pev->wait_value_lo = XSyncValueLow32(pTrigger->test_value); pev->wait_value_lo = XSyncValueLow32(pTrigger->test_value);
pev->wait_value_hi = XSyncValueHigh32(pTrigger->test_value); pev->wait_value_hi = XSyncValueHigh32(pTrigger->test_value);
pev->counter_value_lo = XSyncValueLow32(pTrigger->pCounter->value); pev->counter_value_lo = XSyncValueLow32(pTrigger->pCounter->value);
pev->counter_value_hi = XSyncValueHigh32(pTrigger->pCounter->value); pev->counter_value_hi = XSyncValueHigh32(pTrigger->pCounter->value);
pev->time = currentTime.milliseconds; pev->time = currentTime.milliseconds;
pev->count = num_events - i - 1; /* events remaining */ pev->count = num_events - i - 1; /* events remaining */
pev->destroyed = pTrigger->pCounter->beingDestroyed; pev->destroyed = pTrigger->pCounter->sync.beingDestroyed;
} }
/* swapping will be taken care of by this */ /* swapping will be taken care of by this */
WriteEventsToClient(client, num_events, (xEvent *)pEvents); WriteEventsToClient(client, num_events, (xEvent *)pEvents);
@ -532,7 +532,7 @@ SyncAwaitTriggerFired(SyncTrigger *pTrigger)
* always generated if the counter for one of the triggers is * always generated if the counter for one of the triggers is
* destroyed." * destroyed."
*/ */
if (pAwait->trigger.pCounter->beingDestroyed) if (pAwait->trigger.pCounter->sync.beingDestroyed)
{ {
ppAwait[num_events++] = pAwait; ppAwait[num_events++] = pAwait;
continue; continue;
@ -600,7 +600,7 @@ SyncChangeCounter(SyncCounter *pCounter, CARD64 newval)
pCounter->value = newval; pCounter->value = newval;
/* run through triggers to see if any become true */ /* run through triggers to see if any become true */
for (ptl = pCounter->pTriglist; ptl; ptl = pnext) for (ptl = pCounter->sync.pTriglist; ptl; ptl = pnext)
{ {
pnext = ptl->next; pnext = ptl->next;
if ((*ptl->pTrigger->CheckTrigger)(ptl->pTrigger, oldval)) if ((*ptl->pTrigger->CheckTrigger)(ptl->pTrigger, oldval))
@ -692,7 +692,8 @@ SyncChangeAlarmAttributes(ClientPtr client, SyncAlarm *pAlarm, Mask mask,
XSyncCounter counter; XSyncCounter counter;
Mask origmask = mask; Mask origmask = mask;
counter = pAlarm->trigger.pCounter ? pAlarm->trigger.pCounter->id : None; counter =
pAlarm->trigger.pCounter ? pAlarm->trigger.pCounter->sync.id : None;
while (mask) while (mask)
{ {
@ -781,26 +782,52 @@ SyncChangeAlarmAttributes(ClientPtr client, SyncAlarm *pAlarm, Mask mask,
return Success; return Success;
} }
static SyncObject *
SyncCreate(ClientPtr client, XID id, unsigned char type)
{
SyncObject *pSync;
RESTYPE resType;
unsigned long syncSize;
switch (type) {
case SYNC_COUNTER:
resType = RTCounter;
syncSize = sizeof(SyncCounter);
break;
default:
return NULL;
}
if (!(pSync = (SyncObject *)malloc(syncSize)))
return NULL;
if (!AddResource(id, resType, (pointer) pSync))
{
free(pSync);
return NULL;
}
pSync->client = client;
pSync->id = id;
pSync->pTriglist = NULL;
pSync->beingDestroyed = FALSE;
pSync->type = type;
return pSync;
}
static SyncCounter * static SyncCounter *
SyncCreateCounter(ClientPtr client, XSyncCounter id, CARD64 initialvalue) SyncCreateCounter(ClientPtr client, XSyncCounter id, CARD64 initialvalue)
{ {
SyncCounter *pCounter; SyncCounter *pCounter;
if (!(pCounter = malloc(sizeof(SyncCounter)))) if (!(pCounter = (SyncCounter *)SyncCreate(client,
id,
SYNC_COUNTER)))
return NULL; return NULL;
if (!AddResource(id, RTCounter, (pointer) pCounter))
{
free(pCounter);
return NULL;
}
pCounter->client = client;
pCounter->id = id;
pCounter->value = initialvalue; pCounter->value = initialvalue;
pCounter->pTriglist = NULL;
pCounter->beingDestroyed = FALSE;
pCounter->pSysCounterInfo = NULL; pCounter->pSysCounterInfo = NULL;
return pCounter; return pCounter;
} }
@ -852,7 +879,7 @@ SyncCreateSystemCounter(
psci = malloc(sizeof(SysCounterInfo)); psci = malloc(sizeof(SysCounterInfo));
if (!psci) if (!psci)
{ {
FreeResource(pCounter->id, RT_NONE); FreeResource(pCounter->sync.id, RT_NONE);
return pCounter; return pCounter;
} }
pCounter->pSysCounterInfo = psci; pCounter->pSysCounterInfo = psci;
@ -872,7 +899,7 @@ void
SyncDestroySystemCounter(pointer pSysCounter) SyncDestroySystemCounter(pointer pSysCounter)
{ {
SyncCounter *pCounter = (SyncCounter *)pSysCounter; SyncCounter *pCounter = (SyncCounter *)pSysCounter;
FreeResource(pCounter->id, RT_NONE); FreeResource(pCounter->sync.id, RT_NONE);
} }
static void static void
@ -896,7 +923,7 @@ SyncComputeBracketValues(SyncCounter *pCounter)
XSyncMaxValue(&psci->bracket_greater); XSyncMaxValue(&psci->bracket_greater);
XSyncMinValue(&psci->bracket_less); XSyncMinValue(&psci->bracket_less);
for (pCur = pCounter->pTriglist; pCur; pCur = pCur->next) for (pCur = pCounter->sync.pTriglist; pCur; pCur = pCur->next)
{ {
pTrigger = pCur->pTrigger; pTrigger = pCur->pTrigger;
@ -986,9 +1013,9 @@ FreeCounter(void *env, XID id)
SyncCounter *pCounter = (SyncCounter *) env; SyncCounter *pCounter = (SyncCounter *) env;
SyncTriggerList *ptl, *pnext; SyncTriggerList *ptl, *pnext;
pCounter->beingDestroyed = TRUE; pCounter->sync.beingDestroyed = TRUE;
/* tell all the counter's triggers that the counter has been destroyed */ /* tell all the counter's triggers that the counter has been destroyed */
for (ptl = pCounter->pTriglist; ptl; ptl = pnext) for (ptl = pCounter->sync.pTriglist; ptl; ptl = pnext)
{ {
(*ptl->pTrigger->CounterDestroyed)(ptl->pTrigger); (*ptl->pTrigger->CounterDestroyed)(ptl->pTrigger);
pnext = ptl->next; pnext = ptl->next;
@ -1048,7 +1075,7 @@ FreeAwait(void *addr, XID id)
* the trigger list itself, so don't do it here. * the trigger list itself, so don't do it here.
*/ */
SyncCounter *pCounter = pAwait->trigger.pCounter; SyncCounter *pCounter = pAwait->trigger.pCounter;
if (pCounter && !pCounter->beingDestroyed) if (pCounter && !pCounter->sync.beingDestroyed)
SyncDeleteTriggerFromCounter(&pAwait->trigger); SyncDeleteTriggerFromCounter(&pAwait->trigger);
} }
free(pAwaitUnion); free(pAwaitUnion);
@ -1158,7 +1185,7 @@ ProcSyncListSystemCounters(ClientPtr client)
char *pname_in_reply; char *pname_in_reply;
SysCounterInfo *psci = SysCounterList[i]->pSysCounterInfo; SysCounterInfo *psci = SysCounterList[i]->pSysCounterInfo;
walklist->counter = SysCounterList[i]->id; walklist->counter = SysCounterList[i]->sync.id;
walklist->resolution_hi = XSyncValueHigh32(psci->resolution); walklist->resolution_hi = XSyncValueHigh32(psci->resolution);
walklist->resolution_lo = XSyncValueLow32(psci->resolution); walklist->resolution_lo = XSyncValueLow32(psci->resolution);
namelen = strlen(psci->name); namelen = strlen(psci->name);
@ -1371,7 +1398,7 @@ ProcSyncDestroyCounter(ClientPtr client)
client->errorValue = stuff->counter; client->errorValue = stuff->counter;
return BadAccess; return BadAccess;
} }
FreeResource(pCounter->id, RT_NONE); FreeResource(pCounter->sync.id, RT_NONE);
return Success; return Success;
} }
@ -1677,7 +1704,7 @@ ProcSyncQueryAlarm(ClientPtr client)
rep.sequenceNumber = client->sequence; rep.sequenceNumber = client->sequence;
pTrigger = &pAlarm->trigger; pTrigger = &pAlarm->trigger;
rep.counter = (pTrigger->pCounter) ? pTrigger->pCounter->id : None; rep.counter = (pTrigger->pCounter) ? pTrigger->pCounter->sync.id : None;
#if 0 /* XXX unclear what to do, depends on whether relative value-types #if 0 /* XXX unclear what to do, depends on whether relative value-types
* are "consumed" immediately and are considered absolute from then * are "consumed" immediately and are considered absolute from then
@ -2243,7 +2270,7 @@ static void
IdleTimeBlockHandler(pointer env, struct timeval **wt, pointer LastSelectMask) IdleTimeBlockHandler(pointer env, struct timeval **wt, pointer LastSelectMask)
{ {
XSyncValue idle, old_idle; XSyncValue idle, old_idle;
SyncTriggerList *list = IdleTimeCounter->pTriglist; SyncTriggerList *list = IdleTimeCounter->sync.pTriglist;
SyncTrigger *trig; SyncTrigger *trig;
if (!pIdleTimeValueLess && !pIdleTimeValueGreater) if (!pIdleTimeValueLess && !pIdleTimeValueGreater)
@ -2264,7 +2291,7 @@ IdleTimeBlockHandler(pointer env, struct timeval **wt, pointer LastSelectMask)
* immediately so we can reschedule. * immediately so we can reschedule.
*/ */
for (list = IdleTimeCounter->pTriglist; list; list = list->next) { for (list = IdleTimeCounter->sync.pTriglist; list; list = list->next) {
trig = list->pTrigger; trig = list->pTrigger;
if (trig->CheckTrigger(trig, old_idle)) { if (trig->CheckTrigger(trig, old_idle)) {
AdjustWaitForDelay(wt, 0); AdjustWaitForDelay(wt, 0);
@ -2290,7 +2317,7 @@ IdleTimeBlockHandler(pointer env, struct timeval **wt, pointer LastSelectMask)
idle, &overflow); idle, &overflow);
timeout = min(timeout, XSyncValueLow32 (value)); timeout = min(timeout, XSyncValueLow32 (value));
} else { } else {
for (list = IdleTimeCounter->pTriglist; list; list = list->next) { for (list = IdleTimeCounter->sync.pTriglist; list; list = list->next) {
trig = list->pTrigger; trig = list->pTrigger;
if (trig->CheckTrigger(trig, old_idle)) { if (trig->CheckTrigger(trig, old_idle)) {
timeout = min(timeout, 0); timeout = min(timeout, 0);

16
Xext/syncsrv.h
View File

@ -53,12 +53,20 @@ PERFORMANCE OF THIS SOFTWARE.
#define CARD64 XSyncValue /* XXX temporary! need real 64 bit values for Alpha */ #define CARD64 XSyncValue /* XXX temporary! need real 64 bit values for Alpha */
typedef struct _SyncCounter { /* Sync object types */
#define SYNC_COUNTER 0
typedef struct _SyncObject {
ClientPtr client; /* Owning client. 0 for system counters */ ClientPtr client; /* Owning client. 0 for system counters */
XSyncCounter id; /* resource ID */
CARD64 value; /* counter value */
struct _SyncTriggerList *pTriglist; /* list of triggers */ struct _SyncTriggerList *pTriglist; /* list of triggers */
Bool beingDestroyed; /* in process of going away */ XID id; /* resource ID */
unsigned char type; /* SYNC_* */
Bool beingDestroyed; /* in process of going away */
} SyncObject;
typedef struct _SyncCounter {
SyncObject sync; /* Common sync object data */
CARD64 value; /* counter value */
struct _SysCounterInfo *pSysCounterInfo; /* NULL if not a system counter */ struct _SysCounterInfo *pSysCounterInfo; /* NULL if not a system counter */
} SyncCounter; } SyncCounter;