cciRegCallback

Questa è una funzione che può essere registrata come callback e viene richiamata quando si verifica l'evento registrato. La funzione viene registrata fornendo un puntatore di funzione che corrisponde al seguente typedef:

Sintassi

typedef int (*CciRegCallback)(CciDataContext *, cciCallbackType);

Parametri

type CciDataContext*
E' il puntatore fornito da chi che esegue la chiamata alla funzione di registrazione.
type CciCallbackType
Indica il motivo della callback. E' sempre uno dei valori CciCallbackType specificato nella chiamata di registrazione corrispondente a questa callback.

Valori di restituzione

type CciRegCallbackStatus (definito in BipCci.h)

  • CCI_THREAD_STATE_REGISTRATION_RETAIN: questo codice di ritorno è utilizzato per una callback che deve rimanere registrata come una funzione callback su un determinato thread.
  • CCI_THREAD_STATE_REGISTRATION_REMOVE: questo codice di ritorno è utilizzato per indicare che deve essere annullata la registrazione della callback e che non deve essere richiamata su questo thread a meno che non ne sia stata annullata la registrazione. Se viene restituito un qualsiasi altro valore, viene scritta un'avvertenza su una registrazione e viene assunto CCI_THREAD_STATE_REGISTRATION_RETAIN.
Durante l'esecuzione di questa funzione, è possibile che il nodo o il programma di analisi che ha eseguito la registrazione della funzione sia già stato eliminato. Non si deve quindi richiamare una funzione di utilità del programma di analisi o del nodo che dipende dall'esistenza di un nodo o programma di analisi. Le uniche funzioni di utilità che potrebbero essere richiamate da questa callback sono:
  • cciLog
  • cciUserTrace
  • cciServiceTrace
  • cciUserDebugTrace
  • cciServiceDebugTrace
  • cciIsTraceActive

Per ciascuna di queste cinque funzioni di utilità di traccia, il parametro CciObject deve essere NULL.

Esempio

Dichiarare il seguente struct e funzione:

typedef struct {
    int         id;
}MyContext;

static int registered=0;

CciRegCallbackStatus switchThreadStateChange(CciDataContext *context, CciCallbackType type)
{
  char    traceText[256];
  char*   typeStr=0;
  MyContext* myContext = (MyContext*)context;

  if (type==CCI_THREAD_STATE_IDLE){
      typeStr = "idle";      
  }else if(type==CCI_THREAD_STATE_INSTANCE_END){
      typeStr = "instance end";
  }else if (type==CCI_THREAD_STATE_TERMINATION){
      typeStr = "termination";
  }else{
      typeStr = "unknown";
  }

  memset(traceText,0,256);
  sprintf(traceText,"switchThreadStateChange: context id = %d, thread state %s",myContext->id,typeStr);
  cciServiceTrace(NULL,
                  NULL,
                  traceText);
  return CCI_THREAD_STATE_REGISTRATION_RETAIN;

}

Inserire il seguente codice nella funzione _Switch_evaluate negli esempi per abilitare la lettura della traccia del servizio e per vedere quando il thread di elaborazione del messaggio cambia stato:

/*registro del cambiamento di stato del thread*/
  CciMessageContext* messageContext = cniGetMessageContext(NULL,message);
  CciThreadContext*  threadContext  = cniGetThreadContext(NULL,messageContext);
  
  static MyContext myContext={1};  

  if(registered==0){
    cciRegisterForThreadStateChange(
                   NULL,
                   threadContext,
                   & myContext,
                   switchThreadStateChange,
                   CCI_THREAD_STATE_IDLE | 
                   CCI_THREAD_STATE_INSTANCE_END |
                   CCI_THREAD_STATE_TERMINATION);

    registered=1;
  
  }

In questo esempio viene registrato solo il primo thread che riceve un messaggio. Se è necessario registrare tutti i thread che ricevono un messaggio, è necessario che le estensioni definite dall'utente ricordino i thread sui quali sono registrate.

Mediante l'uso del parametro userContext è possibile vedere come i dati vengono passati dal codice dove è registrata la funzione callback alla funzione callback attuale.

Quando si registra la callback, viene passato un puntatore ad un'istanza dello struct MyContext. Questo è lo stesso puntatore così come ripassato alla funzione callback. Per accertarsi che il puntatore sia ancora valido quando viene ripassato alla callback, un'istanza dello struct viene dichiarata come statica. Un altro modo per accertarsi che il puntatore sia valido è quello di assegnare memoria sull'heap.

Nella funzione callback, il parametro userContext può essere impostato su un (MyContext*). E' possibile fare riferimento allo struct MyContext di origine mediante questo indirizzo. Ciò consente il passaggio dei dati dal codice in cui la callback è registrata nella funzione callback.

Riferimenti correlati
cciRegisterForThreadStateChange
Informazioni particolari | Marchi | Download | Libreria | Supporto | Commenti
Copyright IBM Corporation 1999, 2006 Ultimo aggiornamento: ago 17, 2006
as24650_