/**
* Initialize pipeline object state for given context.
*/
void
_mesa_init_pipeline(struct gl_context *ctx)
{
ctx->Pipeline.Objects = _mesa_NewHashTable();
ctx->Pipeline.Current = NULL;
}
static bool
intel_init_bufmgr(struct intel_screen *intelScreen)
{
__DRIscreen *spriv = intelScreen->driScrnPriv;
int num_fences = 0;
intelScreen->no_hw = getenv("INTEL_NO_HW") != NULL;
intelScreen->bufmgr = intel_bufmgr_gem_init(spriv->fd, BATCH_SZ);
if (intelScreen->bufmgr == NULL) {
fprintf(stderr, "[%s:%u] Error initializing buffer manager.\n",
__func__, __LINE__);
return false;
}
if (!intel_get_param(spriv, I915_PARAM_NUM_FENCES_AVAIL, &num_fences) ||
num_fences == 0) {
fprintf(stderr, "[%s: %u] Kernel 2.6.29 required.\n", __func__, __LINE__);
return false;
}
drm_intel_bufmgr_gem_enable_fenced_relocs(intelScreen->bufmgr);
intelScreen->named_regions = _mesa_NewHashTable();
intelScreen->relaxed_relocations = 0;
intelScreen->relaxed_relocations |=
intel_get_boolean(spriv, I915_PARAM_HAS_RELAXED_DELTA) << 0;
return true;
}
/**
* Allocate/init the context state related to query objects.
*/
void
_mesa_init_query(GLcontext *ctx)
{
#if FEATURE_ARB_occlusion_query
ctx->Query.QueryObjects = _mesa_NewHashTable();
ctx->Query.CurrentOcclusionObject = NULL;
#endif
}
/**
* Initialize vertex array state for given context.
*/
void
_mesa_init_varray(struct gl_context *ctx)
{
ctx->Array.DefaultArrayObj = _mesa_new_array_object(ctx, 0);
_mesa_reference_array_object(ctx, &ctx->Array.ArrayObj,
ctx->Array.DefaultArrayObj);
ctx->Array.Objects = _mesa_NewHashTable();
}
/**
* Initialize vertex array state for given context.
*/
void
_mesa_init_varray(struct gl_context *ctx)
{
ctx->Array.DefaultArrayObj = ctx->Driver.NewArrayObject(ctx, 0);
_mesa_reference_array_object(ctx, &ctx->Array.ArrayObj,
ctx->Array.DefaultArrayObj);
ctx->Array.ActiveTexture = 0; /* GL_ARB_multitexture */
ctx->Array.Objects = _mesa_NewHashTable();
}
/**
* Initialize pipeline object state for given context.
*/
void
_mesa_init_pipeline(struct gl_context *ctx)
{
ctx->Pipeline.Objects = _mesa_NewHashTable();
ctx->Pipeline.Current = NULL;
/* Install a default Pipeline */
ctx->Pipeline.Default = _mesa_new_pipeline_object(ctx, 0);
_mesa_reference_pipeline_object(ctx, &ctx->_Shader, ctx->Pipeline.Default);
}
/**
* Allocate/init the context state related to query objects.
*/
void
_mesa_init_queryobj(struct gl_context *ctx)
{
ctx->Query.QueryObjects = _mesa_NewHashTable();
ctx->Query.CurrentOcclusionObject = NULL;
ctx->Const.QueryCounterBits.SamplesPassed = 64;
ctx->Const.QueryCounterBits.TimeElapsed = 64;
ctx->Const.QueryCounterBits.Timestamp = 64;
ctx->Const.QueryCounterBits.PrimitivesGenerated = 64;
ctx->Const.QueryCounterBits.PrimitivesWritten = 64;
}
void
_mesa_test_hash_functions(void)
{
int a, b, c;
struct _mesa_HashTable *t;
t = _mesa_NewHashTable();
_mesa_HashInsert(t, 501, &a);
_mesa_HashInsert(t, 10, &c);
_mesa_HashInsert(t, 0xfffffff8, &b);
/*_mesa_HashPrint(t);*/
assert(_mesa_HashLookup(t,501));
assert(!_mesa_HashLookup(t,1313));
assert(_mesa_HashFindFreeKeyBlock(t, 100));
_mesa_DeleteHashTable(t);
test_hash_walking();
}
/**
* Per-context init for transform feedback.
*/
void
_mesa_init_transform_feedback(struct gl_context *ctx)
{
/* core mesa expects this, even a dummy one, to be available */
assert(ctx->Driver.NewTransformFeedback);
ctx->TransformFeedback.DefaultObject =
ctx->Driver.NewTransformFeedback(ctx, 0);
assert(ctx->TransformFeedback.DefaultObject->RefCount == 1);
reference_transform_feedback_object(&ctx->TransformFeedback.CurrentObject,
ctx->TransformFeedback.DefaultObject);
assert(ctx->TransformFeedback.DefaultObject->RefCount == 2);
ctx->TransformFeedback.Objects = _mesa_NewHashTable();
_mesa_reference_buffer_object(ctx,
&ctx->TransformFeedback.CurrentBuffer,
ctx->Shared->NullBufferObj);
}
int main(int argc, char *argv[])
{
int a, b, c;
struct HashTable *t;
_mesa_printf("&a = %p\n", &a);
_mesa_printf("&b = %p\n", &b);
t = _mesa_NewHashTable();
_mesa_HashInsert(t, 501, &a);
_mesa_HashInsert(t, 10, &c);
_mesa_HashInsert(t, 0xfffffff8, &b);
_mesa_HashPrint(t);
_mesa_printf("Find 501: %p\n", _mesa_HashLookup(t,501));
_mesa_printf("Find 1313: %p\n", _mesa_HashLookup(t,1313));
_mesa_printf("Find block of 100: %d\n", _mesa_HashFindFreeKeyBlock(t, 100));
_mesa_DeleteHashTable(t);
return 0;
}
struct bufmgr *
bm_intel_Attach(struct intel_context *intel)
{
GLuint i;
for (i = 0; i < nr_bms; i++)
if (bufmgr_pool[i].driFd == intel->driFd) {
bufmgr_pool[i].refcount++;
_mesa_printf("retrieive old bufmgr for fd %d\n",
bufmgr_pool[i].driFd);
return &bufmgr_pool[i];
}
if (nr_bms < BM_MAX) {
struct bufmgr *bm = &bufmgr_pool[nr_bms++];
_mesa_printf("create new bufmgr for fd %d\n", intel->driFd);
bm->driFd = intel->driFd;
bm->hash = _mesa_NewHashTable();
bm->refcount = 1;
_glthread_INIT_MUTEX(bm->mutex);
drmGetLock(bm->driFd, intel->hHWContext, 0);
BM_CKFATAL(drmMMAllocBufferPool(bm->driFd, mmPoolRing, 0,
DRM_MM_TT | DRM_MM_NO_EVICT |
DRM_MM_READ | DRM_MM_EXE |
BM_BATCHBUFFER, 1024 * 1024, 4096,
&bm->batchPool));
drmUnlock(bm->driFd, intel->hHWContext);
return bm;
}
_mesa_printf("failed to create new bufmgr for fd %d\n", intel->driFd);
return NULL;
}
/**
* Test walking over all the entries in a hash table.
*/
static void
test_hash_walking(void)
{
struct _mesa_HashTable *t = _mesa_NewHashTable();
const GLuint limit = 50000;
GLuint i;
/* create some entries */
for (i = 0; i < limit; i++) {
GLuint dummy;
GLuint k = (rand() % (limit * 10)) + 1;
while (_mesa_HashLookup(t, k)) {
/* id already in use, try another */
k = (rand() % (limit * 10)) + 1;
}
_mesa_HashInsert(t, k, &dummy);
}
/* walk over all entries */
{
GLuint k = _mesa_HashFirstEntry(t);
GLuint count = 0;
while (k) {
GLuint knext = _mesa_HashNextEntry(t, k);
assert(knext != k);
_mesa_HashRemove(t, k);
count++;
k = knext;
}
assert(count == limit);
k = _mesa_HashFirstEntry(t);
assert(k==0);
}
_mesa_DeleteHashTable(t);
}
/**
* Allocate and initialize a shared context state structure.
* Initializes the display list, texture objects and vertex programs hash
* tables, allocates the texture objects. If it runs out of memory, frees
* everything already allocated before returning NULL.
*
* \return pointer to a gl_shared_state structure on success, or NULL on
* failure.
*/
struct gl_shared_state *
_mesa_alloc_shared_state(GLcontext *ctx)
{
struct gl_shared_state *shared;
GLuint i;
shared = CALLOC_STRUCT(gl_shared_state);
if (!shared)
return NULL;
_glthread_INIT_MUTEX(shared->Mutex);
shared->DisplayList = _mesa_NewHashTable();
shared->TexObjects = _mesa_NewHashTable();
shared->Programs = _mesa_NewHashTable();
#if FEATURE_ARB_vertex_program
shared->DefaultVertexProgram = (struct gl_vertex_program *)
ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
#endif
#if FEATURE_ARB_fragment_program
shared->DefaultFragmentProgram = (struct gl_fragment_program *)
ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
#endif
#if FEATURE_ATI_fragment_shader
shared->ATIShaders = _mesa_NewHashTable();
shared->DefaultFragmentShader = _mesa_new_ati_fragment_shader(ctx, 0);
#endif
#if FEATURE_ARB_shader_objects
shared->ShaderObjects = _mesa_NewHashTable();
#endif
#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
shared->BufferObjects = _mesa_NewHashTable();
#endif
shared->ArrayObjects = _mesa_NewHashTable();
/* Create default texture objects */
for (i = 0; i < NUM_TEXTURE_TARGETS; i++) {
/* NOTE: the order of these enums matches the TEXTURE_x_INDEX values */
static const GLenum targets[NUM_TEXTURE_TARGETS] = {
GL_TEXTURE_2D_ARRAY_EXT,
GL_TEXTURE_1D_ARRAY_EXT,
GL_TEXTURE_CUBE_MAP,
GL_TEXTURE_3D,
GL_TEXTURE_RECTANGLE_NV,
GL_TEXTURE_2D,
GL_TEXTURE_1D
};
shared->DefaultTex[i] = ctx->Driver.NewTextureObject(ctx, 0, targets[i]);
}
/* sanity check */
assert(shared->DefaultTex[TEXTURE_1D_INDEX]->RefCount == 1);
/* Mutex and timestamp for texobj state validation */
_glthread_INIT_MUTEX(shared->TexMutex);
shared->TextureStateStamp = 0;
#if FEATURE_EXT_framebuffer_object
shared->FrameBuffers = _mesa_NewHashTable();
shared->RenderBuffers = _mesa_NewHashTable();
#endif
return shared;
}
