| # 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] | |