igt_spin_new()

#define             igt_spin_new(fd, ...)

igt_spin_set_timeout ()

void
igt_spin_set_timeout (igt_spin_t *spin,
                      int64_t ns);

Specify a timeout. This ends the recursive batch associated with spin after the timeout has elapsed.

igt_spin_reset ()

void
igt_spin_reset (igt_spin_t *spin);

Reset the state of spin, allowing its reuse.

igt_spin_end ()

void
igt_spin_end (igt_spin_t *spin);

End the spinner associated with spin manually.

igt_spin_free ()

void
igt_spin_free (int fd,
               igt_spin_t *spin);

This function does the necessary post-processing after starting a spin with igt_spin_new() and then frees it.

READ_ONCE ()

return
READ_ONCE ();

igt_terminate_spins ()

void
igt_terminate_spins (void);

igt_unshare_spins ()

void
igt_unshare_spins (void);

IGT_CORK()

#define IGT_CORK(name, cork_type) struct igt_cork name = { .type = cork_type, .fd = -1}

IGT_CORK_HANDLE()

#define IGT_CORK_HANDLE(name) IGT_CORK(name, CORK_VGEM_HANDLE)

IGT_CORK_FENCE()

#define IGT_CORK_FENCE(name) IGT_CORK(name, CORK_SYNC_FD)

igt_cork_plug ()

uint32_t
igt_cork_plug (struct igt_cork *cork,
               int fd);

This function provides a mechanism to stall submission. It provides two blocking methods:

VGEM_BO. Imports a vgem bo with a fence attached to it. This bo can be used as a dependency during submission to stall execution until the fence is signaled.

SW_SYNC: Creates a timeline and then a fence on that timeline. The fence can be used as an input fence to a request, the request will be stalled until the fence is signaled.

The parameters required to unblock the execution and to cleanup are stored in the provided cork structure.

igt_cork_unplug ()

void
igt_cork_unplug (struct igt_cork *cork);

This function unblocks the execution by signaling the fence attached to the imported bo and does the necessary post-processing.

NOTE: the handle returned by igt_cork_plug is not closed during this phase.

igt_spin_t

typedef struct {
	unsigned int handle;
	timer_t timer;
	struct igt_list link;

	uint32_t *condition;
	uint32_t cmd_precondition;

	int out_fence;
	struct drm_i915_gem_exec_object2 obj[2];
#define IGT_SPIN_BATCH   1
	struct drm_i915_gem_execbuffer2 execbuf;
	uint32_t poll_handle;
	uint32_t *poll;
#define SPIN_POLL_START_IDX 0
} igt_spin_t;

struct igt_spin_factory

struct igt_spin_factory {
	uint32_t ctx;
	uint32_t dependency;
	unsigned int engine;
	unsigned int flags;
};

Start a recursive batch on a ring. Immediately returns a igt_spin_t that contains the batch's handle that can be waited upon. The returned structure must be passed to igt_spin_free() for post-processing.

IGT_SPIN_FENCE_OUT

#define IGT_SPIN_FENCE_OUT     (1 << 0)

IGT_SPIN_POLL_RUN

#define IGT_SPIN_POLL_RUN      (1 << 1)

IGT_SPIN_FAST

#define IGT_SPIN_FAST          (1 << 2)

IGT_SPIN_NO_PREEMPTION

#define IGT_SPIN_NO_PREEMPTION (1 << 3)

enum igt_cork_type

struct igt_cork_vgem

struct igt_cork_vgem {
	int device;
	uint32_t fence;
};

struct igt_cork_sw_sync

struct igt_cork_sw_sync {
	int timeline;
};

struct igt_cork

struct igt_cork {
	enum igt_cork_type type;

	union {
		int fd;

		struct igt_cork_vgem vgem;
		struct igt_cork_sw_sync sw_sync;
	};
};