58 lines
2.4 KiB
Plaintext
58 lines
2.4 KiB
Plaintext
|
///////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
//
|
||
|
|
|
||
|
|
using System;
|
||
|
|
|
||
|
|
namespace Microsoft.SingSharp {
|
||
|
|
/// <summary>
|
||
|
|
/// This is the Base class for all Custom allocators.
|
||
|
|
///
|
||
|
|
/// <i>Custom Allocator support</i>
|
||
|
|
///
|
||
|
|
/// Custom allocators enable Sing# programs to allocate memory explicitly in a variety of
|
||
|
|
/// different heaps.
|
||
|
|
///
|
||
|
|
/// Pointers to objects in custom allocation regions have types that are tagged by an optional
|
||
|
|
/// type modifier pointing to the Allocator class. E.g., a pointer to a struct S in allocation
|
||
|
|
/// heap controlled by type A is given type
|
||
|
|
///
|
||
|
|
/// (S* ) opt A
|
||
|
|
///
|
||
|
|
/// In the same vein, we can support vectors in these allocation regions by tagging the pointer
|
||
|
|
/// with a vector type A[]
|
||
|
|
///
|
||
|
|
/// (S* ) opt A[] represents a vector of S in allocation region managed by A.
|
||
|
|
///
|
||
|
|
///
|
||
|
|
/// The idea is that given a pointer tagged with an allocator, we can perform operations
|
||
|
|
/// specific to that allocator, such as getting the array length, freeing the block, or
|
||
|
|
/// indirect to the data (if the allocator uses that representation).
|
||
|
|
///
|
||
|
|
/// A pointer without an allocator tag is thus interpreted no differently than the CLR normally
|
||
|
|
/// would treat it, and no special operations can be performed on it, in particular, it cannot
|
||
|
|
/// be freed.
|
||
|
|
///
|
||
|
|
/// The allocator tagging also enables us to make sure we free the pointer with the right
|
||
|
|
/// allocator and to restrict certain operations to particular heaps, for example message sends
|
||
|
|
/// only accept pointers allocated in the exchange heap.
|
||
|
|
///
|
||
|
|
/// </summary>
|
||
|
|
public class CustomAllocator {
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// This is a marker used in optional modifiers to encode that a pointer to a custom heap is actually a
|
||
|
|
/// vector and can be indexed. We encode these as T* opt(Allocator) opt(CustomVector)
|
||
|
|
///
|
||
|
|
/// History:
|
||
|
|
/// We used to encode these as T* opt(Allocator[]), but the array type in the modifier position throws
|
||
|
|
/// off IL readers such as ABSIL.
|
||
|
|
/// </summary>
|
||
|
|
public class CustomVector {
|
||
|
|
public unsafe static void Expose(void* arr, int idx) { }
|
||
|
|
public unsafe static void UnExpose(void* arr, int idx) { }
|
||
|
|
}
|
||
|
|
}
|