public VKBuffer(
string name, Graphics graphics, long count, BufferUsages usages, MemoryProperties memoryProperties,
BufferCreateFlags flags = BufferCreateFlags.None, SharingMode sharingMode = SharingMode.Exclusive,
int[] queueFamilyIndices = null
)
{
Name = name;
Graphics = graphics;
Count = count;
Size = count * Interop.SizeOf <T>();
Usages = usages;
Buffer = Graphics.Device.CreateBuffer(new BufferCreateInfo(
size: Size,
usages: usages,
flags: flags,
sharingMode: sharingMode,
queueFamilyIndices: queueFamilyIndices
));
var reqs = Buffer.GetMemoryRequirements();
DeviceMemory = Graphics.Device.AllocateMemory(new MemoryAllocateInfo(
reqs.Size,
graphics.GetMemoryTypeIndex(reqs.MemoryTypeBits, memoryProperties)
));
Buffer.BindMemory(DeviceMemory);
}
/**
* Get the index of a memory type that has all the requested property bits set
*
* @param typeBits Bitmask with bits set for each memory type supported by the resource to request for (from VkMemoryRequirements)
* @param properties Bitmask of properties for the memory type to request
* @param (Optional) memTypeFound Pointer to a bool that is set to true if a matching memory type has been found
*
* @return Index of the requested memory type
*
* @throw Throws an exception if memTypeFound is null and no memory type could be found that supports the requested properties
*/
public uint getMemoryType(uint typeBits, VkMemoryPropertyFlagBits properties, uint *memTypeFound = null)
{
for (uint i = 0; i < MemoryProperties.memoryTypeCount; i++)
{
if ((typeBits & 1) == 1)
{
if ((MemoryProperties.GetMemoryType(i).propertyFlags & properties) == properties)
{
if (memTypeFound != null)
{
*memTypeFound = True;
}
return(i);
}
}
typeBits >>= 1;
}
if (memTypeFound != null)
{
*memTypeFound = False;
return(0);
}
else
{
throw new InvalidOperationException("Could not find a matching memory type");
}
}
public void Upload()
{
string s = input.text;
MemoryProperties newMemory = new MemoryProperties(ProgramManager.currentUser, s);
ProgramManager.memories.Add(newMemory);
input.text = "";
SceneManager.LoadScene(1);
}
internal int GetMemoryType(MemoryProperties properties, int supportedTypesFilter = ~0)
{
for (int i = 0; i < deviceMemoryProperties.MemoryTypes.Length; i++)
{
if (supportedTypesFilter.HasBitSet(i) &&
(deviceMemoryProperties.MemoryTypes[i].PropertyFlags & properties) == properties)
{
return(i);
}
}
throw new Exception(
$"[{nameof(HostDevice)}] Device {Name} has no memory-type that fits requirements");
}
public static uint GetMemoryType(uint typeBits, VkMemoryPropertyFlags properties)
{
for (uint i = 0; i < MemoryProperties.memoryTypeCount; i++)
{
if ((typeBits & 1) == 1)
{
if ((MemoryProperties.GetMemoryType(i).propertyFlags & properties) == properties)
{
return(i);
}
}
typeBits >>= 1;
}
return(0);
}
public InstructionNode(Instruction instruction, MethodDefinition method)
{
Instruction = instruction;
Method = method;
// TODO rework, this must precede StackPopCount for now, yuck
DataFlowBackRelated = new DataFlowBackArgList(this);
StackPushCount = GetStackPushCount(instruction);
StackPopCount = GetStackPopCount(instruction);
MemoryReadCount = MemoryProperties.GetMemReadCount(instruction.OpCode.Code);
MemoryStoreCount = MemoryProperties.GetMemStoreCount(instruction.OpCode.Code);
ProgramFlowBackRoutes = new ProgramFlowBackRoutes(this);
ProgramFlowForwardRoutes = new ProgramFlowForwardRoutes(this);
DataFlowForwardRelated = new DataFlowForwardArgList(this);
SingleUnitBackRelated = new SingleUnitBackRelated(this);
SingleUnitForwardRelated = new SingleUnitForwardRelated(this);
SingleUnitNodes = new List <InstructionNode>();
MethodNameForSerilization = method.Name;
MyGuid = Guid.NewGuid();
_BranchProperties = new BranchProperties(this);
BranchProperties.BaseBranch.AddTwoWay(this);
}
public void CreateBufferMemory <T>(string bufName, MemoryProperties props)
{
if (mDeviceMems.ContainsKey(bufName))
{
Misc.SafeInvoke(eErrorSpam, "Buffer " + bufName + " already has a chunk of mem allocated...");
return;
}
Buffer buf = mBuffers[bufName];
DeviceMemory dm;
MemoryRequirements mr = buf.GetMemoryRequirements();
MemoryAllocateInfo mai = new MemoryAllocateInfo();
mai.AllocationSize = mr.Size;
mai.MemoryTypeIndex = FindMemoryType(mr.MemoryTypeBits, props);
dm = mLogical.AllocateMemory(mai);
mDeviceMems.Add(bufName, dm);
}
public Response Get()
{
MemoryProperties Properties = Core.Instance.Memory.RepopulateAndGetProperties();
if (Utils.Hardware.isRunningRaspberryPi)
{
return(new Response
{
Model = Properties,
Template = Templates.Memory
});
}
else
{
return(new Response
{
StatusCode = System.Net.HttpStatusCode.Redirect,
Location = new Uri(Context.Paths.Base + Context.Paths.Home)
});
}
}
public static int GetMemReadCount(Code code)
{
return(MemoryProperties.GetMemReadCount(code));
}
/// <summary>
/// Get the memory type index for the required memory type
/// </summary>
/// <param name="memoryTypeBits"></param>
/// <param name="properties"></param>
/// <returns></returns>
public int GetMemoryTypeIndex(int memoryTypeBits, MemoryProperties properties)
{
return(MemoryProperties.MemoryTypes.IndexOf(memoryTypeBits, properties));
}
private MemoryInformation[][] GetRegions()
{
var addy = new IntPtr();
IList <MemoryInformation> regions
= new List <MemoryInformation>();
while (true)
{
var memInf = new MemoryInformation();
int memDump = Pinvoke.VirtualQueryEx(_access.Handle, addy,
out memInf, Marshal.SizeOf(memInf));
if (memDump == 0)
{
return(DivideRegions(regions));
}
var memProps = MemoryProperties.Parse(memInf);
if (!memProps.State.IsCommited &&
!memProps.Protect.IsGuard &&
memProps.Protect.IsReadOnly)
{
goto ADDY;
}
if (!Settings.MemPrivate)
{
if (memProps.Type.IsPrivate)
{
goto ADDY;
}
}
if (!Settings.MemImage)
{
if (memProps.Type.IsImageMapped)
{
goto ADDY;
}
}
if (!Settings.MemMapped)
{
if (memProps.Type.IsMapped)
{
goto ADDY;
}
}
if (Settings.Writable != ScanType.BOTH)
{
if (Settings.Writable == ScanType.ONLY)
{
if (!memProps.Protect.IsWritable)
{
goto ADDY;
}
}
else if (memProps.Protect.IsWritable)
{
goto ADDY;
}
}
if (Settings.CopyOnWrite != ScanType.BOTH)
{
if (Settings.CopyOnWrite == ScanType.ONLY)
{
if (!memProps.Protect.IsCopyOnWrite)
{
goto ADDY;
}
}
else if (memProps.Protect.IsCopyOnWrite)
{
goto ADDY;
}
}
if (Settings.Executable != ScanType.BOTH)
{
if (Settings.Executable == ScanType.ONLY)
{
if (!memProps.Protect.IsExecutable)
{
goto ADDY;
}
}
else if (memProps.Protect.IsExecutable)
{
goto ADDY;
}
}
regions.Add(memInf);
ADDY:
addy = new IntPtr(memInf.BaseAddress.ToInt32()
+ (int)memInf.RegionSize);
}
}
/// <summary>
/// Gets the index of the <see cref="MemoryType"/> that has all the requested <paramref
/// name="properties"/> set or <c>-1</c> if not found.
/// </summary>
/// <param name="memoryTypes">
/// Structures describing the memory types that can be used to access memory allocated from
/// the heaps specified by <see cref="PhysicalDeviceMemoryProperties.MemoryHeaps"/>.
/// </param>
/// <param name="memoryTypeBits">
/// A bitmask of <see cref="MemoryRequirements.MemoryTypeBits"/> that contains one bit set
/// for every memory type supported by the resource.
/// </param>
/// <param name="properties">A bitmask of properties to request.</param>
/// <returns>Index of the requested <see cref="MemoryType"/> or <c>-1</c> if not found.</returns>
/// ///
/// <exception cref="ArgumentNullException"><paramref name="memoryTypes"/> is <c>null</c>.</exception>
public static int IndexOf(this IList <MemoryType> memoryTypes, int memoryTypeBits, MemoryProperties properties)
{
if (memoryTypes == null)
{
throw new ArgumentNullException(nameof(memoryTypes));
}
int count = memoryTypes?.Count ?? 0;
for (int i = 0; i < count; i++)
{
if ((memoryTypeBits & 1) == 1 &&
(memoryTypes[i].PropertyFlags & properties) == properties)
{
return(i);
}
memoryTypeBits >>= 1;
}
return(-1);
}
//from the vulkan tutorial
int FindMemoryType(int typeFilter, MemoryProperties memProps)
{
PhysicalDeviceMemoryProperties pdmp = mLogical.Parent.GetMemoryProperties();
return(pdmp.MemoryTypes.IndexOf(typeFilter, memProps));
}
// find memory type with desired properties.
int FindMemoryType(int memoryTypeBits, MemoryProperties properties)
{
PhysicalDeviceMemoryProperties memoryProperties = physicalDevice.GetMemoryProperties();
return(memoryProperties.MemoryTypes.IndexOf(memoryTypeBits, properties));
}
