private static IOps CreateOps(WorkerFactory.Type type, ITensorAllocator allocator, bool verbose)
{
switch (type)
{
case WorkerFactory.Type.ComputePrecompiled:
return(new PrecompiledComputeOps(ComputeShaderSingleton.Instance.kernels,
ComputeShaderSingleton.Instance.referenceKernels, allocator, verbose));
case WorkerFactory.Type.Compute:
return(new ComputeOps(ComputeShaderSingleton.Instance.kernels,
ComputeShaderSingleton.Instance.referenceKernels, allocator, verbose));
case WorkerFactory.Type.ComputeRef:
return(new ReferenceComputeOps(ComputeShaderSingleton.Instance.referenceKernels, allocator));
case WorkerFactory.Type.CSharpBurst:
return(new BurstCPUOps(allocator));
case WorkerFactory.Type.CSharp:
return(new UnsafeArrayCPUOps(allocator));
default:
return(new ReferenceCPUOps(allocator));
}
}
public static WorkerFactory.Type ResolveAutoType(WorkerFactory.Type type)
{
if (type != WorkerFactory.Type.Auto)
{
return(type);
}
return(GetBestTypeForDevice(WorkerFactory.Device.Auto));
}
internal static IWorker CreateWorker(WorkerFactory.Type type, Model model, string[] additionalOutputs, string[] trimOutputs, WorkerFactory.WorkerConfiguration workerConfiguration, IModelExecutionsReporter modelExecutionsReporter = null)
{
type = ResolveAutoType(type);
var compareAgainstType = ResolveAutoType(workerConfiguration.compareAgainstType);
Assert.AreNotEqual(type, WorkerFactory.Type.Auto);
Assert.AreNotEqual(compareAgainstType, WorkerFactory.Type.Auto);
bool compare = type != compareAgainstType;
if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) && !SystemInfo.supportsComputeShaders && !Application.isEditor)
{
D.LogWarning("Compute shaders are not supported on current platform. Falling back to CSharpFast.");
type = WorkerFactory.Type.CSharpBurst;
}
IVars vars;
if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) || WorkerFactory.IsType(compareAgainstType, WorkerFactory.Device.GPU))
{
vars = new ComputeVarsWithSharedModel();
}
else
{
vars = new DefaultVars();
}
ITensorAllocator allocator = vars.GetAllocator();
if (workerConfiguration.verbose)
{
D.Log($"Storage type: {vars.GetType()}. Allocator type: {allocator.GetType()}.");
}
IOps ops = CreateOps(type, allocator, workerConfiguration.verbose);
if (compare)
{
ops = new CompareOps(ops,
CreateOps(compareAgainstType, allocator, workerConfiguration.verbose), workerConfiguration.compareLogLevel, workerConfiguration.compareEpsilon);
}
if (workerConfiguration.verbose || modelExecutionsReporter != null)
{
ops = new VerboseOps(ops, workerConfiguration.verbose);
}
if (Application.isEditor || modelExecutionsReporter != null)
{
ops = new StatsOps(ops);
}
model = ValidateModel(
PatchModel(model, additionalOutputs, trimOutputs));
ops.SetModelExecutionsReporter(modelExecutionsReporter);
return(new GenericWorker(model, ops, vars, workerConfiguration.verbose));
}
public static IWorker CreateWorker(WorkerFactory.Type type, Model model, string[] additionalOutputs, string[] trimOutputs, bool verbose, WorkerFactory.Type compareAgainstType, bool differenceAsError)
{
type = ResolveAutoType(type);
compareAgainstType = ResolveAutoType(compareAgainstType);
Assert.AreNotEqual(type, WorkerFactory.Type.Auto);
Assert.AreNotEqual(compareAgainstType, WorkerFactory.Type.Auto);
bool compare = type != compareAgainstType;
if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) && !SystemInfo.supportsComputeShaders && !Application.isEditor)
{
D.LogWarning("Compute shaders are not supported on current platform. Falling back to CSharpFast.");
type = WorkerFactory.Type.CSharp;
}
IVars vars;
if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) || WorkerFactory.IsType(compareAgainstType, WorkerFactory.Device.GPU))
{
vars = new ComputeVarsWithSharedModel();
}
else
{
vars = new DefaultVars();
}
ITensorAllocator allocator = vars.GetAllocator();
if (verbose)
{
D.Log($"Storage type: {vars.GetType()}. Allocator type: {allocator.GetType()}.");
}
IOps ops = CreateOps(type, allocator, verbose);
if (compare)
{
ops = new CompareOps(ops,
CreateOps(compareAgainstType, allocator, verbose), differenceAsError);
}
if (verbose)
{
ops = new VerboseOps(ops);
}
if (Application.isEditor)
{
ops = new StatsOps(ops);
}
model = ValidateModel(
PatchModel(model, additionalOutputs, trimOutputs));
return(new GenericWorker(model, ops, vars, verbose));
}
public BarracudaWorker(NNModel nnModel, WorkerFactory.Type type)
{
bool verbose = false;
model = ModelLoader.Load(nnModel, verbose);
worker = WorkerFactory.CreateWorker(type, model, verbose);
var kernels = ComputeShaderSingleton.Instance.kernels;
ops = new PrecompiledComputeOps(kernels, kernels[0]);
}
internal static WorkerFactory.Type ValidateType(WorkerFactory.Type type)
{
type = ResolveAutoType(type);
Assert.AreNotEqual(type, WorkerFactory.Type.Auto);
if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) && !ComputeShaderSingleton.Instance.supported)
{
type = WorkerFactory.Type.PixelShader;
}
return(type);
}
internal static WorkerFactory.Type ValidateType(WorkerFactory.Type type)
{
type = ResolveAutoType(type);
Assert.AreNotEqual(type, WorkerFactory.Type.Auto);
if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) && !ComputeShaderSingleton.Instance.supported)
{
D.LogWarning(
$"SystemInfo.supportsComputeShaders: {SystemInfo.supportsComputeShaders}. Falling back to {WorkerFactory.Type.CSharp}");
type = WorkerFactory.Type.CSharp;
}
return(type);
}
public static IOps CreateOps(WorkerFactory.Type type, bool verbose = false)
{
WorkerFactory.ValidateType(type);
switch (type)
{
case WorkerFactory.Type.ComputePrecompiled:
return new PrecompiledComputeOps(ComputeShaderSingleton.Instance.kernels,
ComputeShaderSingleton.Instance.referenceKernels, verbose: verbose);
case WorkerFactory.Type.Compute:
return new ComputeOps(ComputeShaderSingleton.Instance.kernels,
ComputeShaderSingleton.Instance.referenceKernels, verbose: verbose);
case WorkerFactory.Type.ComputeRef:
return new ReferenceComputeOps(ComputeShaderSingleton.Instance.referenceKernels);
case WorkerFactory.Type.CSharp:
return new UnsafeArrayCPUOps();
default:
return new ReferenceCPUOps();
}
}
/// <summary>
/// Updates the output layer names based on the selected model architecture
/// and initializes the Barracuda inference engine witht the selected model.
/// </summary>
private void InitializeBarracuda()
{
// The compiled model used for performing inference
Model m_RunTimeModel;
if (modelType == ModelType.MobileNet)
{
preProcessFunction = Utils.PreprocessMobileNet;
// Compile the model asset into an object oriented representation
m_RunTimeModel = ModelLoader.Load(mobileNetModelAsset);
displacementFWDLayer = m_RunTimeModel.outputs[2];
displacementBWDLayer = m_RunTimeModel.outputs[3];
}
else
{
preProcessFunction = Utils.PreprocessResNet;
// Compile the model asset into an object oriented representation
m_RunTimeModel = ModelLoader.Load(resnetModelAsset);
displacementFWDLayer = m_RunTimeModel.outputs[3];
displacementBWDLayer = m_RunTimeModel.outputs[2];
}
heatmapLayer = m_RunTimeModel.outputs[0];
offsetsLayer = m_RunTimeModel.outputs[1];
// Create a model builder to modify the m_RunTimeModel
ModelBuilder modelBuilder = new ModelBuilder(m_RunTimeModel);
// Add a new Sigmoid layer that takes the output of the heatmap layer
modelBuilder.Sigmoid(predictionLayer, heatmapLayer);
// Validate if backend is supported, otherwise use fallback type.
workerType = WorkerFactory.ValidateType(workerType);
// Create a worker that will execute the model with the selected backend
engine = new Engine(workerType, modelBuilder.model, modelType);
}
public static IWorker CreateWorker(WorkerFactory.Type type, Model model, string[] additionalOutputs = null, string[] trimOutputs = null, bool verbose = false)
{
return(CreateWorker(type, model, additionalOutputs, trimOutputs, verbose, compareAgainstType: type, differenceAsError: false));
}
public static IWorker CreateWorker(WorkerFactory.Type type, Model model, string[] additionalOutputs = null, string[] trimOutputs = null, bool verbose = false)
{
var workerConfiguration = new WorkerFactory.WorkerConfiguration(type, verbose);
return(CreateWorker(type, model, additionalOutputs, trimOutputs, workerConfiguration));
}
public Engine(WorkerFactory.Type workerType, Model model, ModelType modelType)
{
this.workerType = workerType;
worker = WorkerFactory.CreateWorker(workerType, model);
this.modelType = modelType;
}
internal static IWorker CreateWorker(WorkerFactory.Type type, Model model, string[] additionalOutputs, string[] trimOutputs, WorkerFactory.WorkerConfiguration workerConfiguration, IModelExecutionsReporter modelExecutionsReporter = null)
{
type = ResolveAutoType(type);
var compareAgainstType = ResolveAutoType(workerConfiguration.compareAgainstType);
Assert.AreNotEqual(type, WorkerFactory.Type.Auto);
Assert.AreNotEqual(compareAgainstType, WorkerFactory.Type.Auto);
bool compare = type != compareAgainstType;
if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) && !SystemInfo.supportsComputeShaders && !Application.isEditor)
{
type = WorkerFactory.Type.PixelShader;
}
IVars vars;
// PixelShader worker uses Blit/Textures, cannot re-use vars unless the dispatch mechanism allows rendering to sub part of the texture
if ((type == WorkerFactory.Type.PixelShader) || (compareAgainstType == WorkerFactory.Type.PixelShader))
{
vars = new GenericVarsWithReuse();
}
else
{
if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) || WorkerFactory.IsType(compareAgainstType, WorkerFactory.Device.GPU))
{
vars = new ComputeVarsWithSharedModel();
}
else
{
vars = new DefaultVars();
}
}
ITensorAllocator allocator = vars.GetAllocator();
if ((type == WorkerFactory.Type.PixelShader) || (compareAgainstType == WorkerFactory.Type.PixelShader))
{
allocator = new TensorCachingByShapeAllocator();
}
if (workerConfiguration.verbose)
{
D.Log($"Storage type: {vars.GetType()}. Allocator type: {allocator.GetType()}.");
}
IOps ops = CreateOps(type, allocator, workerConfiguration.verbose);
if (compare)
{
ops = new CompareOps(ops,
CreateOps(compareAgainstType, allocator, workerConfiguration.verbose), workerConfiguration.compareLogLevel, workerConfiguration.compareEpsilon);
}
if (workerConfiguration.verbose || modelExecutionsReporter != null)
{
ops = new VerboseOps(ops, workerConfiguration.verbose);
}
if (Application.isEditor || modelExecutionsReporter != null)
{
ops = new StatsOps(ops);
}
model = ValidateModel(
PatchModel(model, additionalOutputs, trimOutputs));
ops.SetModelExecutionsReporter(modelExecutionsReporter);
return(new GenericWorker(model, ops, vars, workerConfiguration.verbose, workerConfiguration.takeoverWeights));
}
