src/gallium/winsys/dri/intel/ws_dri_fencemgr.h

   1 #ifndef DRI_FENCEMGR_H
   2 #define DRI_FENCEMGR_H
   3
   4 #include <stdint.h>
   5 #include <stdlib.h>
   6
   7 struct _DriFenceObject;
   8 struct _DriFenceMgr;
   9
  10 /*
  11  * Do a quick check to see if the fence manager has registered the fence
  12  * object as signaled. Note that this function may return a false negative
  13  * answer.
  14  */
  15 extern uint32_t driFenceSignaledTypeCached(struct _DriFenceObject *fence);
  16
  17 /*
  18  * Check if the fence object is signaled. This function can be substantially
  19  * more expensive to call than the above function, but will not return a false
  20  * negative answer. The argument "flush_type" sets the types that the
  21  * underlying mechanism must make sure will eventually signal.
  22  */
  23 extern int driFenceSignaledType(struct _DriFenceObject *fence,
  24                                 uint32_t flush_type, uint32_t *signaled);
  25
  26 /*
  27  * Convenience functions.
  28  */
  29
  30 static inline int driFenceSignaled(struct _DriFenceObject *fence,
  31                                    uint32_t flush_type)
  32 {
  33     uint32_t signaled_types;
  34     int ret = driFenceSignaledType(fence, flush_type, &signaled_types);
  35     if (ret)
  36         return 0;
  37     return ((signaled_types & flush_type) == flush_type);
  38 }
  39
  40 static inline int driFenceSignaledCached(struct _DriFenceObject *fence,
  41                                          uint32_t flush_type)
  42 {
  43     uint32_t signaled_types =
  44         driFenceSignaledTypeCached(fence);
  45
  46     return ((signaled_types & flush_type) == flush_type);
  47 }
  48
  49 /*
  50  * Reference a fence object.
  51  */
  52 extern struct _DriFenceObject *driFenceReference(struct _DriFenceObject *fence);
  53
  54 /*
  55  * Unreference a fence object. The fence object pointer will be reset to NULL.
  56  */
  57
  58 extern void driFenceUnReference(struct _DriFenceObject **pFence);
  59
  60
  61 /*
  62  * Wait for a fence to signal the indicated fence_type.
  63  * If "lazy_hint" is true, it indicates that the wait may sleep to avoid
  64  * busy-wait polling.
  65  */
  66 extern int driFenceFinish(struct _DriFenceObject *fence, uint32_t fence_type,
  67                           int lazy_hint);
  68
  69 /*
  70  * Create a DriFenceObject for manager "mgr".
  71  *
  72  * "private" is a pointer that should be used for the callbacks in
  73  * struct _DriFenceMgrCreateInfo.
  74  *
  75  * if private_size is nonzero, then the info stored at *private, with size
  76  * private size will be copied and the fence manager will instead use a
  77  * pointer to the copied data for the callbacks in
  78  * struct _DriFenceMgrCreateInfo. In that case, the object pointed to by
  79  * "private" may be destroyed after the call to driFenceCreate.
  80  */
  81 extern struct _DriFenceObject *driFenceCreate(struct _DriFenceMgr *mgr,
  82                                               uint32_t fence_class,
  83                                               uint32_t fence_type,
  84                                               void *private,
  85                                               size_t private_size);
  86
  87 extern uint32_t driFenceType(struct _DriFenceObject *fence);
  88
  89 /*
  90  * Fence creations are ordered. If a fence signals a fence_type,
  91  * it is safe to assume that all fences of the same class that was
  92  * created before that fence has signaled the same type.
  93  */
  94
  95 #define DRI_FENCE_CLASS_ORDERED (1 << 0)
  96
  97 struct _DriFenceMgrCreateInfo {
  98     uint32_t flags;
  99     uint32_t num_classes;
 100     int (*signaled) (struct _DriFenceMgr *mgr, void *private, uint32_t flush_type,
 101                      uint32_t *signaled_type);
 102     int (*finish) (struct _DriFenceMgr *mgr, void *private, uint32_t fence_type, int lazy_hint);
 103     int (*unreference) (struct _DriFenceMgr *mgr, void **private);
 104 };
 105
 106 extern struct _DriFenceMgr *
 107 driFenceMgrCreate(const struct _DriFenceMgrCreateInfo *info);
 108
 109 void
 110 driFenceMgrUnReference(struct _DriFenceMgr **pMgr);
 111
 112 extern struct _DriFenceMgr *
 113 driFenceMgrTTMInit(int fd);
 114
 115 #endif