#include "r600_formats.h"
#include "compute_memory_pool.h"
#include "evergreen_compute_internal.h"
+#include <inttypes.h>
-static struct r600_resource_texture * create_pool_texture(struct r600_screen * screen,
+static struct r600_texture * create_pool_texture(struct r600_screen * screen,
unsigned size_in_dw)
{
struct pipe_resource templ;
- struct r600_resource_texture * tex;
+ struct r600_texture * tex;
if (size_in_dw == 0) {
return NULL;
templ.depth0 = 1;
templ.array_size = 1;
- tex = (struct r600_resource_texture *)r600_texture_create(
+ tex = (struct r600_texture *)r600_texture_create(
&screen->screen, &templ);
/* XXX: Propagate this error */
assert(tex && "Out of memory");
* Creates a new pool
*/
struct compute_memory_pool* compute_memory_pool_new(
- int64_t initial_size_in_dw,
struct r600_screen * rscreen)
{
struct compute_memory_pool* pool = (struct compute_memory_pool*)
CALLOC(sizeof(struct compute_memory_pool), 1);
+ COMPUTE_DBG("* compute_memory_pool_new()\n");
+
+ pool->screen = rscreen;
+ return pool;
+}
+
+static void compute_memory_pool_init(struct compute_memory_pool * pool,
+ unsigned initial_size_in_dw)
+{
+
+ COMPUTE_DBG("* compute_memory_pool_init() initial_size_in_dw = %ld\n",
+ initial_size_in_dw);
+
+ /* XXX: pool->shadow is used when the buffer needs to be resized, but
+ * resizing does not work at the moment.
+ * pool->shadow = (uint32_t*)CALLOC(4, pool->size_in_dw);
+ */
pool->next_id = 1;
pool->size_in_dw = initial_size_in_dw;
- pool->screen = rscreen;
pool->bo = (struct r600_resource*)create_pool_texture(pool->screen,
pool->size_in_dw);
- pool->shadow = (uint32_t*)CALLOC(4, pool->size_in_dw);
-
- return pool;
}
/**
*/
void compute_memory_pool_delete(struct compute_memory_pool* pool)
{
+ COMPUTE_DBG("* compute_memory_pool_delete()\n");
free(pool->shadow);
if (pool->bo) {
pool->screen->screen.resource_destroy((struct pipe_screen *)
int last_end = 0;
+ COMPUTE_DBG("* compute_memory_prealloc_chunk() size_in_dw = %ld\n",
+ size_in_dw);
+
for (item = pool->item_list; item; item = item->next) {
if (item->start_in_dw > -1) {
if (item->start_in_dw-last_end > size_in_dw) {
{
struct compute_memory_item* item;
+ COMPUTE_DBG("* compute_memory_postalloc_chunck() start_in_dw = %ld\n",
+ start_in_dw);
+
for (item = pool->item_list; item; item = item->next) {
if (item->next) {
if (item->start_in_dw < start_in_dw
void compute_memory_grow_pool(struct compute_memory_pool* pool,
struct pipe_context * pipe, int new_size_in_dw)
{
+ COMPUTE_DBG("* compute_memory_grow_pool() new_size_in_dw = %d\n",
+ new_size_in_dw);
+
assert(new_size_in_dw >= pool->size_in_dw);
- new_size_in_dw += 1024 - (new_size_in_dw % 1024);
+ assert(!pool->bo && "Growing the global memory pool is not yet "
+ "supported. You will see this message if you are trying to"
+ "use more than 64 kb of memory");
+
+ if (!pool->bo) {
+ compute_memory_pool_init(pool, 1024 * 16);
+ } else {
+ /* XXX: Growing memory pools does not work at the moment. I think
+ * it is because we are using fragment shaders to copy data to
+ * the new texture and some of the compute registers are being
+ * included in the 3D command stream. */
+ fprintf(stderr, "Warning: growing the global memory pool to"
+ "more than 64 kb is not yet supported\n");
+ new_size_in_dw += 1024 - (new_size_in_dw % 1024);
+
+ COMPUTE_DBG(" Aligned size = %d\n", new_size_in_dw);
- if (pool->bo) {
compute_memory_shadow(pool, pipe, 1);
- }
- pool->shadow = (uint32_t*)realloc(pool->shadow, new_size_in_dw*4);
- pool->size_in_dw = new_size_in_dw;
- if (pool->bo) {
+ pool->shadow = realloc(pool->shadow, new_size_in_dw*4);
+ pool->size_in_dw = new_size_in_dw;
pool->screen->screen.resource_destroy(
(struct pipe_screen *)pool->screen,
(struct pipe_resource *)pool->bo);
pool->screen,
pool->size_in_dw);
compute_memory_shadow(pool, pipe, 0);
- } else {
- pool->bo = (struct r600_resource*)create_pool_texture(
- pool->screen,
- pool->size_in_dw);
}
}
{
struct compute_memory_item chunk;
+ COMPUTE_DBG("* compute_memory_shadow() device_to_host = %d\n",
+ device_to_host);
+
chunk.id = 0;
chunk.start_in_dw = 0;
chunk.size_in_dw = pool->size_in_dw;
int64_t allocated = 0;
int64_t unallocated = 0;
+ COMPUTE_DBG("* compute_memory_finalize_pending()\n");
+
for (item = pool->item_list; item; item = item->next) {
COMPUTE_DBG("list: %i %p\n", item->start_in_dw, item->next);
}
{
struct compute_memory_item *item, *next;
+ COMPUTE_DBG("* compute_memory_free() id + %ld \n", id);
+
for (item = pool->item_list; item; item = next) {
next = item->next;
}
}
- fprintf(stderr, "Internal error, invalid id %ld "
+ fprintf(stderr, "Internal error, invalid id %"PRIi64" "
"for compute_memory_free\n", id);
assert(0 && "error");
{
struct compute_memory_item *new_item;
- COMPUTE_DBG("Alloc: %i\n", size_in_dw);
+ COMPUTE_DBG("* compute_memory_alloc() size_in_dw = %ld\n", size_in_dw);
new_item = (struct compute_memory_item *)
CALLOC(sizeof(struct compute_memory_item), 1);
assert(gart);
+ COMPUTE_DBG("* compute_memory_transfer() device_to_host = %d, "
+ "offset_in_chunk = %d, size = %d\n", device_to_host,
+ offset_in_chunk, size);
+
if (device_to_host)
{
xfer = pipe->get_transfer(pipe, gart, 0, PIPE_TRANSFER_READ,
projects / mesa.git / blobdiff