string_buffer(void* mem_ctx)
	{
		m_Capacity = 512;
		m_Ptr = (char*)ralloc_size(mem_ctx, m_Capacity);
		m_Size = 0;
		m_Ptr[0] = 0;
	}
Ejemplo n.º 2
0
void
vc4_init_cl(struct vc4_context *vc4, struct vc4_cl *cl)
{
        cl->base = ralloc_size(vc4, 1);
        cl->next = cl->base;
        cl->size = 0;
}
Ejemplo n.º 3
0
glsl_type::glsl_type(const glsl_type *array, unsigned length) :
   base_type(GLSL_TYPE_ARRAY),
   sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
   sampler_type(0),
   vector_elements(0), matrix_columns(0),
   name(NULL), length(length)
{
   this->fields.array = array;
   /* Inherit the gl type of the base. The GL type is used for
    * uniform/statevar handling in Mesa and the arrayness of the type
    * is represented by the size rather than the type.
    */
   this->gl_type = array->gl_type;

   /* Allow a maximum of 10 characters for the array size.  This is enough
    * for 32-bits of ~0.  The extra 3 are for the '[', ']', and terminating
    * NUL.
    */
   const unsigned name_length = (unsigned)strlen(array->name) + 10 + 3;
   char *const n = (char *) ralloc_size(this->mem_ctx, name_length);

   if (length == 0)
      snprintf(n, name_length, "%s[]", array->name);
   else
      snprintf(n, name_length, "%s[%u]", array->name, length);

   this->name = n;
}
Ejemplo n.º 4
0
static void
copy_blob_to_driver_cache_blob(struct blob *blob, struct gl_program *prog)
{
   prog->driver_cache_blob = ralloc_size(NULL, blob->size);
   memcpy(prog->driver_cache_blob, blob->data, blob->size);
   prog->driver_cache_blob_size = blob->size;
}
Ejemplo n.º 5
0
	/* Callers of this ralloc-based new need not call delete. It's
	* easier to just ralloc_free 'ctx' (or any of its ancestors). */
	static void* operator new(size_t size, void *ctx)
	{
		void *node;

		node = ralloc_size(ctx, size);
		check(node != NULL);

		return node;
	}
Ejemplo n.º 6
0
static struct keybox *
make_keybox(void *mem_ctx,
            enum iris_program_cache_id cache_id,
            const void *key,
            uint32_t key_size)
{
   struct keybox *keybox =
      ralloc_size(mem_ctx, sizeof(struct keybox) + key_size);

   keybox->cache_id = cache_id;
   keybox->size = key_size;
   memcpy(keybox->data, key, key_size);

   return keybox;
}
Ejemplo n.º 7
0
static struct vtn_access_chain *
vtn_access_chain_extend(struct vtn_builder *b, struct vtn_access_chain *old,
                        unsigned new_ids)
{
   struct vtn_access_chain *chain;

   unsigned new_len = old->length + new_ids;
   chain = ralloc_size(b, sizeof(*chain) + new_len * sizeof(chain->link[0]));

   chain->var = old->var;
   chain->length = new_len;

   for (unsigned i = 0; i < old->length; i++)
      chain->link[i] = old->link[i];

   return chain;
}
Ejemplo n.º 8
0
/* Test that we can read and write some large objects, (exercising the code in
 * the blob_write functions to realloc blob->data.
 */
static void
test_big_objects(void)
{
   void *ctx = ralloc_context(NULL);
   struct blob blob;
   struct blob_reader reader;
   int size = 1000;
   int count = 1000;
   size_t i;
   char *buf;

   blob_init(&blob);

   /* Initialize our buffer. */
   buf = ralloc_size(ctx, size);
   for (i = 0; i < size; i++) {
      buf[i] = i % 256;
   }

   /* Write it many times. */
   for (i = 0; i < count; i++) {
      blob_write_bytes(&blob, buf, size);
   }

   blob_reader_init(&reader, blob.data, blob.size);

   /* Read and verify it many times. */
   for (i = 0; i < count; i++) {
      expect_equal_bytes((uint8_t *) buf, blob_read_bytes(&reader, size), size,
                         "read of large objects");
   }

   expect_equal(reader.end - reader.data, reader.current - reader.data,
                "number of bytes read reading large objects");

   expect_equal(false, reader.overrun,
                "overrun flag not set reading large objects");

   blob_finish(&blob);
   ralloc_free(ctx);
}
static void
brw_track_state_batch(struct brw_context *brw,
		      enum state_struct_type type,
		      uint32_t offset,
		      int size)
{
   struct intel_batchbuffer *batch = &brw->intel.batch;

   if (!brw->state_batch_list) {
      /* Our structs are always aligned to at least 32 bytes, so
       * our array doesn't need to be any larger
       */
      brw->state_batch_list = ralloc_size(brw, sizeof(*brw->state_batch_list) *
					  batch->bo->size / 32);
   }

   brw->state_batch_list[brw->state_batch_count].offset = offset;
   brw->state_batch_list[brw->state_batch_count].size = size;
   brw->state_batch_list[brw->state_batch_count].type = type;
   brw->state_batch_count++;
}
Ejemplo n.º 10
0
glsl_type::glsl_type(const glsl_type *array, unsigned length) :
   base_type(GLSL_TYPE_ARRAY),
   sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
   sampler_type(0), interface_packing(0),
   vector_elements(0), matrix_columns(0),
   name(NULL), length(length)
{
   this->fields.array = array;
   /* Inherit the gl type of the base. The GL type is used for
    * uniform/statevar handling in Mesa and the arrayness of the type
    * is represented by the size rather than the type.
    */
   this->gl_type = array->gl_type;

   /* Allow a maximum of 10 characters for the array size.  This is enough
    * for 32-bits of ~0.  The extra 3 are for the '[', ']', and terminating
    * NUL.
    */
   const unsigned name_length = (unsigned)strlen(array->name) + 10 + 3;
   char *const n = (char *) ralloc_size(this->mem_ctx, name_length);

   if (length == 0)
      snprintf(n, name_length, "%s[]", array->name);
   else {
      /* insert outermost dimensions in the correct spot
       * otherwise the dimension order will be backwards
       */
      const char *pos = strchr(array->name, '[');
      if (pos) {
         int idx = pos - array->name;
         snprintf(n, idx+1, "%s", array->name);
         snprintf(n + idx, name_length - idx, "[%u]%s",
                  length, array->name + idx);
      } else {
         snprintf(n, name_length, "%s[%u]", array->name, length);
      }
   }

   this->name = n;
}
void
vc4_simulator_init(struct vc4_screen *screen)
{
        screen->simulator_mem_size = 256 * 1024 * 1024;
        screen->simulator_mem_base = ralloc_size(screen,
                                                 screen->simulator_mem_size);

        /* We supply our own memory so that we can have more aperture
         * available (256MB instead of simpenrose's default 64MB).
         */
        simpenrose_init_hardware_supply_mem(screen->simulator_mem_base,
                                            screen->simulator_mem_size);

        /* Carve out low memory for tile allocation overflow.  The kernel
         * should be automatically handling overflow memory setup on real
         * hardware, but for simulation we just get one shot to set up enough
         * overflow memory before execution.  This overflow mem will be used
         * up over the whole lifetime of simpenrose (not reused on each
         * flush), so it had better be big.
         */
        simpenrose_supply_overflow_mem(0, OVERFLOW_SIZE);
}
Ejemplo n.º 12
0
glsl_type::glsl_type(const glsl_type *array, unsigned length) :
    base_type(GLSL_TYPE_ARRAY),
    sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
    inner_type(0),
    vector_elements(0), matrix_columns(0),
    name(NULL), length(length), patch_length(0)
{
    this->fields.array = array;

    /* Allow a maximum of 10 characters for the array size.  This is enough
    * for 32-bits of ~0.  The extra 3 are for the '[', ']', and terminating
    * NUL.
    */
    const size_t name_length = strlen(array->name) + 10 + 3;
    char *const n = (char *)ralloc_size(this->mem_ctx, name_length);

    if (length == 0)
        snprintf(n, name_length, "%s[]", array->name);
    else
        snprintf(n, name_length, "%s[%u]", array->name, length);

    this->name = n;
}
Ejemplo n.º 13
0
 /* Callers of this ralloc-based new need not call delete. It's
  * easier to just ralloc_free 'ctx' (or any of its ancestors). */
 static void* operator new(size_t size, void *ctx)
 {
    void *entry = ralloc_size(ctx, size);
    assert(entry != NULL);
    return entry;
 }
Ejemplo n.º 14
0
static SolarSystem *load_from_config(ALLEGRO_CONFIG *cfg)
{
	SolarSystem *solsys;
	char **primary_names;
	const char *name;
	long num_bodies;
	ALLEGRO_CONFIG_SECTION *sec;
	int i;

	/* First pass: Determine the number of bodies in the file */
	num_bodies = 0;
	sec = NULL;
	while ((name = get_next_config_section(cfg, &sec)) != NULL)
	{
		if (name[0] != '\0')
			num_bodies++;
	}

	if (num_bodies == 0)
		return NULL; /* Empty solarsystem */

	solsys = ralloc_size(NULL, sizeof(SolarSystem) + num_bodies*sizeof(Body));
	if (solsys == NULL)
		return NULL;
	solsys->num_bodies = num_bodies;
	primary_names = ralloc_array(solsys, char *, num_bodies);
	if (primary_names == NULL)
	{
		ralloc_free(solsys);
		return NULL;
	}

	/* Second pass: Load all celestial bodies */
	i = 0;
	sec = NULL;
	while ((name = get_next_config_section(cfg, &sec)) != NULL && i < num_bodies)
	{
		if (name[0] == '\0')
			continue;

		solsys->body[i].ctx = solsys;
		if (!load_body(cfg, name, &solsys->body[i], &primary_names[i]))
		{
			log_err("Couldn't load body %s\n", name);
			ralloc_free(solsys);
			return NULL;
		}
		i++;
	}

	if (i < num_bodies)
		log_err("Internal consistency error\n");

	/* Third pass: Connect each satellite body to its primary */
	for (i = 0; i < num_bodies; i++)
	{
		Body *body = &solsys->body[i];
		char *primary_name = primary_names[i];
		if (primary_name == NULL) /* Independent body */
			continue;

		/* Look for the primary */
		body->primary = NULL;
		for (int j = 0; j < num_bodies; j++)
		{
			Body *body2 = &solsys->body[j];
			if (strcmp(primary_name, body2->name) == 0)
			{
				body->primary = body2;
				break;
			}
		}
		if (body->primary == NULL)
		{
			log_err("Couldn't find %s's primary: %s\n", body->name,
					primary_name);
			ralloc_free(solsys);
			return NULL;
		}
		ralloc_free(primary_name);
		primary_name = NULL; /* Won't ever be used again */

		body->primary->num_satellites++;
		body->primary->satellite = reralloc(solsys, body->primary->satellite,
				Body *, body->primary->num_satellites);
		if (body->primary->satellite == NULL)
		{
			log_err("Out of memory\n");
			ralloc_free(solsys);
			return NULL;
		}
		body->primary->satellite[body->primary->num_satellites - 1] = body;

		body->orbit.epoch = 0;
		body->orbit.period = M_TWO_PI *
				sqrt(CUBE(body->orbit.SMa) / body->primary->grav_param);
		body->orbit.plane_orientation = quat_euler(RAD(body->orbit.LAN),
				RAD(body->orbit.Inc),
				RAD(body->orbit.APe));
	}

	ralloc_free(primary_names);
	return solsys;
}
Ejemplo n.º 15
0
Archivo: ir3.c Proyecto: Unr34ler/mesa
/* simple allocator to carve allocations out of an up-front allocated heap,
 * so that we can free everything easily in one shot.
 */
void * ir3_alloc(struct ir3 *shader, int sz)
{
	return ralloc_size(shader, sz);
}
Ejemplo n.º 16
0
Archivo: cache.c Proyecto: etnaviv/mesa
struct program_cache *
cache_create(void)
{
   void *local;
   struct program_cache *cache = NULL;
   char *path, *max_size_str;
   uint64_t max_size;
   int fd = -1;
   struct stat sb;
   size_t size;

   /* A ralloc context for transient data during this invocation. */
   local = ralloc_context(NULL);
   if (local == NULL)
      goto fail;

   /* At user request, disable shader cache entirely. */
   if (getenv("MESA_GLSL_CACHE_DISABLE"))
      goto fail;

   /* Determine path for cache based on the first defined name as follows:
    *
    *   $MESA_GLSL_CACHE_DIR
    *   $XDG_CACHE_HOME/mesa
    *   <pwd.pw_dir>/.cache/mesa
    */
   path = getenv("MESA_GLSL_CACHE_DIR");
   if (path && mkdir_if_needed(path) == -1) {
      goto fail;
   }

   if (path == NULL) {
      char *xdg_cache_home = getenv("XDG_CACHE_HOME");

      if (xdg_cache_home) {
         if (mkdir_if_needed(xdg_cache_home) == -1)
            goto fail;

         path = concatenate_and_mkdir(local, xdg_cache_home, "mesa");
         if (path == NULL)
            goto fail;
      }
   }

   if (path == NULL) {
      char *buf;
      size_t buf_size;
      struct passwd pwd, *result;

      buf_size = sysconf(_SC_GETPW_R_SIZE_MAX);
      if (buf_size == -1)
         buf_size = 512;

      /* Loop until buf_size is large enough to query the directory */
      while (1) {
         buf = ralloc_size(local, buf_size);

         getpwuid_r(getuid(), &pwd, buf, buf_size, &result);
         if (result)
            break;

         if (errno == ERANGE) {
            ralloc_free(buf);
            buf = NULL;
            buf_size *= 2;
         } else {
            goto fail;
         }
      }

      path = concatenate_and_mkdir(local, pwd.pw_dir, ".cache");
      if (path == NULL)
         goto fail;

      path = concatenate_and_mkdir(local, path, "mesa");
      if (path == NULL)
         goto fail;
   }

   cache = ralloc(NULL, struct program_cache);
   if (cache == NULL)
      goto fail;

   cache->path = ralloc_strdup(cache, path);
   if (cache->path == NULL)
      goto fail;

   path = ralloc_asprintf(local, "%s/index", cache->path);
   if (path == NULL)
      goto fail;

   fd = open(path, O_RDWR | O_CREAT | O_CLOEXEC, 0644);
   if (fd == -1)
      goto fail;

   if (fstat(fd, &sb) == -1)
      goto fail;

   /* Force the index file to be the expected size. */
   size = sizeof(*cache->size) + CACHE_INDEX_MAX_KEYS * CACHE_KEY_SIZE;
   if (sb.st_size != size) {
      if (ftruncate(fd, size) == -1)
         goto fail;
   }

   /* We map this shared so that other processes see updates that we
    * make.
    *
    * Note: We do use atomic addition to ensure that multiple
    * processes don't scramble the cache size recorded in the
    * index. But we don't use any locking to prevent multiple
    * processes from updating the same entry simultaneously. The idea
    * is that if either result lands entirely in the index, then
    * that's equivalent to a well-ordered write followed by an
    * eviction and a write. On the other hand, if the simultaneous
    * writes result in a corrupt entry, that's not really any
    * different than both entries being evicted, (since within the
    * guarantees of the cryptographic hash, a corrupt entry is
    * unlikely to ever match a real cache key).
    */
   cache->index_mmap = mmap(NULL, size, PROT_READ | PROT_WRITE,
                            MAP_SHARED, fd, 0);
   if (cache->index_mmap == MAP_FAILED)
      goto fail;
   cache->index_mmap_size = size;

   close(fd);

   cache->size = (uint64_t *) cache->index_mmap;
   cache->stored_keys = cache->index_mmap + sizeof(uint64_t);

   max_size = 0;

   max_size_str = getenv("MESA_GLSL_CACHE_MAX_SIZE");
   if (max_size_str) {
      char *end;
      max_size = strtoul(max_size_str, &end, 10);
      if (end == max_size_str) {
         max_size = 0;
      } else {
         while (*end && isspace(*end))
            end++;
         switch (*end) {
         case 'K':
         case 'k':
            max_size *= 1024;
            break;
         case 'M':
         case 'm':
            max_size *= 1024*1024;
            break;
         case '\0':
         case 'G':
         case 'g':
         default:
            max_size *= 1024*1024*1024;
            break;
         }
      }
   }

   /* Default to 1GB for maximum cache size. */
   if (max_size == 0)
      max_size = 1024*1024*1024;

   cache->max_size = max_size;

   ralloc_free(local);

   return cache;

 fail:
   if (fd != -1)
      close(fd);
   if (cache)
      ralloc_free(cache);
   ralloc_free(local);

   return NULL;
}