Sto scrivendo un motore di simulazione costituito da un numero di componenti, ognuno dei quali opera su un set fisso di buffer condivisi.
In pratica, la simulazione funzionerà interamente sulla GPU. Tuttavia, quando si sviluppa un componente, è più semplice copiare i buffer dalla GPU, eseguire il componente sulla CPU e scrivere nuovamente i buffer aggiornati, continuando sulla GPU. Quando il componente è stato completamente debugato, viene portato su un kernel GPU.
Voglio pulire il mio codice e scrivere un'interfaccia al 'sistema principale' (il bit che gestisce i buffer) che i componenti useranno, e questo solleva la questione su come presentare i buffer.
Potrei scrivere qualcosa del tipo:
interface ISystem
{
Array x;
Array y;
ComputeBuffer gpu_x;
ComputeBuffer gpu_y;
int numElements;
}
Ma non è molto pulito.
Potrei fare qualcosa di simile:
interface ISystem
{
IBuffer x;
IBuffer y;
int numElements;
}
Dove IBuffer è un'interfaccia adatta per l'uso da parte del codice che vuole l'accesso della CPU al buffer, ma anche quello che lega il buffer ai suoi kernel GPU.
La mia domanda è: quanto lontano dovrei spingere questa astrazione?
Potrei creare un oggetto veramente polimorfico come:
class BufferHelper<T>
{
static implicit operator ComputeBuffer(BufferHelper helper);
static implicit operator T[](BufferHelper helper);
}
La lettura della CPU ha implicazioni significative sulle prestazioni. Tuttavia, chiunque scriverà i componenti lo saprà, e sarà ovvio che ciò avvenga, e dove, dal profiler.
Da un punto di vista delle prestazioni, quindi, non c'è alcun vantaggio per il codice di auto-documentazione avendo interfacce esplicite per i due usi del buffer, ma il mio istinto dice che qualcosa non è giusto con questo design.
Nell'esempio tradizionale di polimorfismo, aggiungerei due interi o concatenare due stringhe; operazioni analoghe se non identiche.
Nel caso precedente, le operazioni (legare un buffer e leggerlo e modificarlo) sono completamente differenti .
Per dirla in un altro modo, questo uso del polimorfismo porta a ridurre la leggibilità e la manutenibilità del codice nascondendo cose che lo sviluppatore dovrebbe vedere?