Spaces:
Sleeping
Sleeping
File size: 2,630 Bytes
e9bc512 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 |
import numpy as np
class CustomVRAM:
def __init__(self, global_mem):
self.global_mem = global_mem
self.texture_registry = {}
self.texture_counter = 0
def load_texture(self, data: np.ndarray, name: str = None) -> str:
if name is None:
name = f"texture_{self.texture_counter}"
self.texture_counter += 1
# Serialize numpy array to bytes
data_bytes = data.tobytes()
data_shape = data.shape
data_dtype = str(data.dtype)
# Store metadata and data in global memory
# For simplicity, we'll store everything contiguously for now.
# In a real system, this would involve more sophisticated memory management.
# Find a suitable address in global memory (very simplified, no actual allocation logic)
# For this simulation, we'll just use a simple counter for addresses.
# In a real scenario, you'd need a proper memory allocator.
address = self.global_mem.allocate_space(len(data_bytes) + 100) # +100 for metadata
# Store shape, dtype, and then data
# This is a very basic serialization. For production, consider more robust methods.
metadata = f"{data_shape};{data_dtype};{len(data_bytes)}".encode("utf-8")
self.global_mem.write(address, list(metadata))
self.global_mem.write(address + len(metadata), list(data_bytes))
self.texture_registry[name] = {
"address": address,
"size": len(data_bytes),
"shape": data_shape,
"dtype": data_dtype,
"metadata_size": len(metadata)
}
return name
def get_texture(self, name: str) -> np.ndarray:
if name not in self.texture_registry:
return None
texture_info = self.texture_registry[name]
address = texture_info["address"]
size = texture_info["size"]
shape = texture_info["shape"]
dtype = texture_info["dtype"]
metadata_size = texture_info["metadata_size"]
# Read data from global memory
data_bytes = bytes(self.global_mem.read(address + metadata_size, size))
# Deserialize bytes to numpy array
return np.frombuffer(data_bytes, dtype=dtype).reshape(shape)
def has_texture(self, name: str) -> bool:
return name in self.texture_registry
def delete_texture(self, name: str):
if name in self.texture_registry:
# In a real system, you'd deallocate the memory.
# For this simulation, we just remove the entry.
del self.texture_registry[name]
|