gdev: updated shared memory support

common/gdev_api.c

@@ -275,12 +275,12 @@ static int __gmemcpy_to_device
 	if (!mem)
 		return -ENOENT;
 
-	gdev_shmem_lock(mem);
-	gdev_shmem_evict(ctx, mem); /* evict data only if necessary */
+	gdev_shm_lock(mem);
+	gdev_shm_evict(ctx, mem); /* evict data only if necessary */
 	ret = __gmemcpy_to_device_locked(ctx, dst_addr, src_buf, size, async, 
 									 ch_size, p_count, vas, mem, dma_mem, 
 									 host_copy);
-	gdev_shmem_unlock(mem);
+	gdev_shm_unlock(mem);
 
 	return ret;
 }
@@ -463,12 +463,12 @@ static int __gmemcpy_from_device
 	if (!mem)
 		return -ENOENT;
 
-	gdev_shmem_lock(mem);
-	gdev_shmem_reload(ctx, mem); /* reload data only if necessary. */
+	gdev_shm_lock(mem);
+	gdev_shm_reload(ctx, mem); /* reload data only if necessary. */
 	ret = __gmemcpy_from_device_locked(ctx, dst_buf, src_addr, size, async, 
 									   ch_size, p_count, vas, mem, dma_mem,
 									   host_copy);
-	gdev_shmem_unlock(mem);
+	gdev_shm_unlock(mem);
 
 	return ret;
 }
@@ -607,9 +607,6 @@ struct gdev_handle *gopen(int minor)
 	h->gdev = gdev;
 	h->dev_id = minor;
 
-	/* insert the created VAS object to the device VAS list. */
-	gdev_vas_list_add(vas);
-
 	GDEV_PRINT("Opened gdev%d\n", minor);
 
 	return h;
@@ -637,9 +634,6 @@ int gclose(struct gdev_handle *h)
 	if (!h->gdev || !h->ctx || !h->vas || !h->se)
 		return -ENOENT;
 
-	/* delete the VAS object from the device VAS list. */
-	gdev_vas_list_del(h->vas);
-
 	/* free the scheduling entity. */
 	gdev_sched_entity_destroy(h->se);
 
@@ -675,15 +669,15 @@ uint64_t gmalloc(struct gdev_handle *h, uint64_t size)
 	gdev->mem_used += size;
 
 	if (gdev->mem_used > gdev->mem_size) {
-		/* a second chance with shared memory (only for device memory). */
-		if (!(mem = gdev_shmem_request(vas, NULL, size)))
+		/* try to share memory with someone (only for device memory). 
+		   the shared memory must be freed in gdev_mem_free() when 
+		   unreferenced by all users. */
+		if (!(mem = gdev_mem_share(vas, size)))
 			goto fail;
 	}
 	else if (!(mem = gdev_mem_alloc(vas, size, GDEV_MEM_DEVICE)))
 		goto fail;
 
-	gdev_mem_list_add(mem, GDEV_MEM_DEVICE);
-
 	return gdev_mem_get_addr(mem);
 
 fail:
@@ -705,7 +699,6 @@ uint64_t gfree(struct gdev_handle *h, uint64_t addr)
 	if (!(mem = gdev_mem_lookup(vas, addr, GDEV_MEM_DEVICE)))
 		goto fail;
 	size = gdev_mem_get_size(mem);
-	gdev_mem_list_del(mem);
 	gdev_mem_free(mem);
 
 	gdev->mem_used -= size;
@@ -732,7 +725,6 @@ void *gmalloc_dma(struct gdev_handle *h, uint64_t size)
 		goto fail;
 	else if (!(mem = gdev_mem_alloc(vas, size, GDEV_MEM_DMA)))
 		goto fail;
-	gdev_mem_list_add(mem, GDEV_MEM_DMA);
 
 	return gdev_mem_get_buf(mem);
 
@@ -755,7 +747,6 @@ uint64_t gfree_dma(struct gdev_handle *h, void *buf)
 	if (!(mem = gdev_mem_lookup(vas, (uint64_t)buf, GDEV_MEM_DMA)))
 		goto fail;
 	size = gdev_mem_get_size(mem);
-	gdev_mem_list_del(mem);
 	gdev_mem_free(mem);
 
 	gdev->dma_mem_used -= size;
@@ -766,30 +757,6 @@ uint64_t gfree_dma(struct gdev_handle *h, void *buf)
 	return 0;
 }
 
-/**
- * gmalloc_shm():
- * allocate new device memory, if necessary, and reference it.
- */
-uint64_t gmalloc_shm(Ghandle h, int key, uint32_t flags, uint64_t size)
-{
-	struct gdev_device *gdev = h->gdev;
-	gdev_vas_t *vas = h->vas;
-	gdev_mem_t *mem;
-
-fail:
-	return 0;
-}
-
-/**
- * gfree_shm():
- * unreference the shared memory space, and free it if necessary.
- */
-uint64_t gfree_shm(Ghandle h, uint64_t addr)
-{
-fail:
-	return 0;
-}
-
 /**
  * gmemcpy_to_device():
  * copy data from @buf to device memory at @addr.
@@ -894,12 +861,12 @@ int gmemcpy_in_device
 	if (!dst || !src)
 		return -ENOENT;
 
-	gdev_shmem_lock(dst);
-	gdev_shmem_lock(src);
+	gdev_shm_lock(dst);
+	gdev_shm_lock(src);
 	fence = gdev_memcpy(ctx, dst_addr, src_addr, size, 0); 
 	gdev_poll(ctx, fence, NULL);
-	gdev_shmem_unlock(src);
-	gdev_shmem_unlock(dst);
+	gdev_shm_unlock(src);
+	gdev_shm_unlock(dst);
 
 	return 0;
 }
@@ -916,10 +883,10 @@ int glaunch(struct gdev_handle *h, struct gdev_kernel *kernel, uint32_t *id)
 
 	gdev_schedule_launch(se);
 
-	gdev_shmem_lock_all(vas);
-	gdev_shmem_reload_all(ctx, vas); /* this reloads data only if necessary */
+	gdev_shm_lock_all(vas);
+	gdev_shm_reload_all(ctx, vas); /* this reloads data only if necessary */
 	*id = gdev_launch(ctx, kernel);
-	gdev_shmem_unlock_all(vas);
+	gdev_shm_unlock_all(vas);
 
 	return 0;
 }
@@ -987,3 +954,21 @@ int gtune(struct gdev_handle *h, uint32_t type, uint32_t value)
 	}
 	return 0;
 }
+
+int gshmget(Ghandle h, int key, uint64_t size, int flags)
+{
+	struct gdev_device *gdev = h->gdev;
+	gdev_vas_t *vas = h->vas;
+
+	return gdev_shm_create(gdev, vas, key, size, flags);
+}
+
+uint64_t gshmat(Ghandle h, int id, uint64_t addr, int flags)
+{
+	return 0;
+}
+
+uint64_t gshmdt(Ghandle h, uint64_t addr)
+{
+	return 0;
+}

common/gdev_api.h

@@ -48,8 +48,6 @@ uint64_t gmalloc(Ghandle h, uint64_t size);
 uint64_t gfree(Ghandle h, uint64_t addr);
 void *gmalloc_dma(Ghandle h, uint64_t size);
 uint64_t gfree_dma(Ghandle h, void *buf);
-uint64_t gmalloc_shm(Ghandle h, int key, uint32_t flags, uint64_t size);
-uint64_t gfree_shm(Ghandle h, uint64_t addr);
 int gmemcpy_to_device(Ghandle h, uint64_t dst_addr, const void *src_buf, uint64_t size);
 int gmemcpy_to_device_async(Ghandle h, uint64_t dst_addr, const void *src_buf, uint64_t size);
 int gmemcpy_user_to_device(Ghandle h, uint64_t dst_addr, const void *src_buf, uint64_t size);
@@ -63,6 +61,10 @@ int glaunch(Ghandle h, struct gdev_kernel *kernel, uint32_t *id);
 int gsync(Ghandle h, uint32_t id, struct gdev_time *timeout);
 int gquery(Ghandle h, uint32_t type, uint64_t *result);
 int gtune(Ghandle h, uint32_t type, uint32_t value);
+int gshmget(Ghandle h, int key, uint64_t size, int flags);
+uint64_t gshmat(Ghandle h, int id, uint64_t addr, int flags);
+uint64_t gshmdt(Ghandle h, uint64_t addr);
+
 
 /**
  * tuning types for Gdev resource management parameters.

common/gdev_arch.h

@@ -65,26 +65,26 @@ gdev_ctx_t *gdev_ctx_new(struct gdev_device *gdev, gdev_vas_t *vas);
 void gdev_ctx_free(gdev_ctx_t *ctx);
 int gdev_ctx_get_cid(gdev_ctx_t *ctx);
 gdev_mem_t *gdev_mem_alloc(gdev_vas_t *vas, uint64_t size, int type);
+gdev_mem_t *gdev_mem_share(gdev_vas_t *vas, uint64_t size);
 void gdev_mem_free(gdev_mem_t *mem);
 void gdev_mem_gc(gdev_vas_t *vas);
-int gdev_shmem_evict(gdev_ctx_t *ctx, gdev_mem_t *mem);
-int gdev_shmem_evict_all(gdev_ctx_t *ctx, gdev_vas_t *vas);
-int gdev_shmem_reload(gdev_ctx_t *ctx, gdev_mem_t *mem);
-int gdev_shmem_reload_all(gdev_ctx_t *ctx, gdev_vas_t *vas);
-gdev_mem_t *gdev_shmem_request(gdev_vas_t *vas, gdev_mem_t *mem, uint64_t size);
-void gdev_shmem_lock(gdev_mem_t *mem);
-void gdev_shmem_unlock(gdev_mem_t *mem);
-void gdev_shmem_lock_all(gdev_vas_t *vas);
-void gdev_shmem_unlock_all(gdev_vas_t *vas);
-int gdev_swap_create(struct gdev_device *gdev, uint32_t size);
-void gdev_swap_destroy(struct gdev_device *gdev);
-void gdev_vas_list_add(gdev_vas_t *vas);
-void gdev_vas_list_del(gdev_vas_t *vas);
-void gdev_mem_list_add(gdev_mem_t *mem, int type);
-void gdev_mem_list_del(gdev_mem_t *mem);
 gdev_mem_t *gdev_mem_lookup(gdev_vas_t *vas, uint64_t addr, int type);
 void *gdev_mem_get_buf(gdev_mem_t *mem);
 uint64_t gdev_mem_get_addr(gdev_mem_t *mem);
 uint64_t gdev_mem_get_size(gdev_mem_t *mem);
+int gdev_shm_create(struct gdev_device *gdev, gdev_vas_t *vas, int key, uint64_t size, int flags);
+int gdev_shm_destroy(struct gdev_device *gdev, int id);
+gdev_mem_t *gdev_shm_attach(gdev_vas_t *vas, gdev_mem_t *mem, uint64_t size);
+void gdev_shm_detach(struct gdev_mem *mem);
+int gdev_shm_evict(gdev_ctx_t *ctx, gdev_mem_t *mem);
+int gdev_shm_evict_all(gdev_ctx_t *ctx, gdev_vas_t *vas);
+int gdev_shm_reload(gdev_ctx_t *ctx, gdev_mem_t *mem);
+int gdev_shm_reload_all(gdev_ctx_t *ctx, gdev_vas_t *vas);
+void gdev_shm_lock(gdev_mem_t *mem);
+void gdev_shm_unlock(gdev_mem_t *mem);
+void gdev_shm_lock_all(gdev_vas_t *vas);
+void gdev_shm_unlock_all(gdev_vas_t *vas);
+int gdev_swap_create(struct gdev_device *gdev, uint32_t size);
+void gdev_swap_destroy(struct gdev_device *gdev);
 
 #endif

common/gdev_device.c

@@ -51,8 +51,9 @@ int gdev_init_device(struct gdev_device *gdev, int minor, void *priv)
 	gdev->parent = NULL;
 	gdev->priv = priv; /* this must be set before calls to gdev_query(). */
 	gdev_list_init(&gdev->vas_list, NULL); /* VAS list. */
+	gdev_list_init(&gdev->shm_list, NULL); /* shared memory list. */
 	gdev_lock_init(&gdev->vas_lock);
-	gdev_mutex_init(&gdev->shmem_mutex);
+	gdev_mutex_init(&gdev->shm_mutex);
 
 	/* architecture-dependent chipset. 
 	   this call must be prior to the following. */
@@ -96,8 +97,9 @@ int gdev_init_virtual_device
 	gdev->dma_mem_size = phys->dma_mem_size * mem_util / 100;
 	gdev->chipset = phys->chipset;
 	gdev_list_init(&gdev->vas_list, NULL); /* VAS list. */
+	gdev_list_init(&gdev->shm_list, NULL); /* shared memory list. */
 	gdev_lock_init(&gdev->vas_lock);
-	gdev_mutex_init(&gdev->shmem_mutex);
+	gdev_mutex_init(&gdev->shm_mutex);
 
 	/* create the swap memory object, if configured, for the virtual device. */
 	if (GDEV_SWAP_MEM_SIZE > 0) {

common/gdev_device.h

@@ -51,8 +51,9 @@ struct gdev_device {
 	void *sched_thread; /* scheduler thread */
 	struct gdev_device *parent; /* only for virtual devices */
 	struct gdev_list vas_list; /* list of VASes allocated to this device */
+	struct gdev_list shm_list; /* list of VASes allocated to this device */
 	gdev_lock_t vas_lock;
-	gdev_mutex_t shmem_mutex;
+	gdev_mutex_t shm_mutex;
 	gdev_mem_t *swap; /* reserved swap memory space */
 };