Better handling of Future handles

.gitignore

@@ -30,6 +30,7 @@ $tf*/
 nuget/
 packages/
 *.ide/
+.vs/
 
 fdb_c.dll
 

FdbBurner/Program.cs

@@ -102,7 +102,7 @@ private static async Task BurnerThread(IFdbDatabase db, CancellationToken ct)
 								? rnd.Next()
 								: pos + i;
 
-							tr.Set(folder.Pack(x, Suffix), Value);
+							tr.Set(folder.Keys.Encode(x, Suffix), Value);
 							Interlocked.Increment(ref Keys);
 						}
 						pos += N;

FdbShell/Commands/BasicCommands.cs

@@ -68,17 +68,17 @@ public static async Task Dir(string[] path, IFdbTuple extras, DirectoryBrowseOpt
 						{
 							if (!(subfolder is FdbDirectoryPartition))
 							{
-								long count = await Fdb.System.EstimateCountAsync(db, subfolder.ToRange(), ct);
-								log.WriteLine("  {0,-12} {1,-12} {3,9:N0} {2}", FdbKey.Dump(subfolder.Copy().Key), subfolder.Layer.IsNullOrEmpty ? "-" : ("<" + subfolder.Layer.ToUnicode() + ">"), name, count);
+								long count = await Fdb.System.EstimateCountAsync(db, subfolder.Keys.ToRange(), ct);
+								log.WriteLine("  {0,-12} {1,-12} {3,9:N0} {2}", FdbKey.Dump(FdbSubspace.Copy(subfolder).Key), subfolder.Layer.IsNullOrEmpty ? "-" : ("<" + subfolder.Layer.ToUnicode() + ">"), name, count);
 							}
 							else
 							{
-								log.WriteLine("  {0,-12} {1,-12} {3,9} {2}", FdbKey.Dump(subfolder.Copy().Key), subfolder.Layer.IsNullOrEmpty ? "-" : ("<" + subfolder.Layer.ToUnicode() + ">"), name, "-");
+								log.WriteLine("  {0,-12} {1,-12} {3,9} {2}", FdbKey.Dump(FdbSubspace.Copy(subfolder).Key), subfolder.Layer.IsNullOrEmpty ? "-" : ("<" + subfolder.Layer.ToUnicode() + ">"), name, "-");
 							}
 						}
 						else
 						{
-							log.WriteLine("  {0,-12} {1,-12} {2}", FdbKey.Dump(subfolder.Copy().Key), subfolder.Layer.IsNullOrEmpty ? "-" : ("<" + subfolder.Layer.ToUnicode() + ">"), name);
+							log.WriteLine("  {0,-12} {1,-12} {2}", FdbKey.Dump(FdbSubspace.Copy(subfolder).Key), subfolder.Layer.IsNullOrEmpty ? "-" : ("<" + subfolder.Layer.ToUnicode() + ">"), name);
 						}
 					}
 					else
@@ -115,7 +115,7 @@ public static async Task CreateDirectory(string[] path, IFdbTuple extras, IFdbDa
 			log.WriteLine("- Created under {0} [{1}]", FdbKey.Dump(folder.Key), folder.Key.ToHexaString(' '));
 
 			// look if there is already stuff under there
-			var stuff = await db.ReadAsync((tr) => tr.GetRange(folder.ToRange()).FirstOrDefaultAsync(), cancellationToken: ct);
+			var stuff = await db.ReadAsync((tr) => tr.GetRange(folder.Keys.ToRange()).FirstOrDefaultAsync(), cancellationToken: ct);
 			if (stuff.Key.IsPresent)
 			{
 				log.WriteLine("CAUTION: There is already some data under {0} !");
@@ -216,7 +216,7 @@ public static async Task Count(string[] path, IFdbTuple extras, IFdbDatabase db,
 				return;
 			}
 
-			var copy = folder.Copy();
+			var copy = FdbSubspace.Copy(folder);
 			log.WriteLine("# Counting keys under {0} ...", FdbKey.Dump(copy.Key));
 
 			var progress = new Progress<FdbTuple<long, Slice>>((state) =>
@@ -245,7 +245,7 @@ public static async Task Show(string[] path, IFdbTuple extras, bool reverse, IFd
 				log.WriteLine("# Content of {0} [{1}]", FdbKey.Dump(folder.Key), folder.Key.ToHexaString(' '));
 				var keys = await db.QueryAsync((tr) =>
 					{
-						var query = tr.GetRange(folder.ToRange());
+						var query = tr.GetRange(folder.Keys.ToRange());
 						return reverse
 							? query.Reverse().Take(count)
 							: query.Take(count + 1);
@@ -255,7 +255,7 @@ public static async Task Show(string[] path, IFdbTuple extras, bool reverse, IFd
 					if (reverse) keys.Reverse();
 					foreach (var key in keys.Take(count))
 					{
-						log.WriteLine("...{0} = {1}", FdbKey.Dump(folder.Extract(key.Key)), key.Value.ToAsciiOrHexaString());
+						log.WriteLine("...{0} = {1}", FdbKey.Dump(folder.ExtractKey(key.Key)), key.Value.ToAsciiOrHexaString());
 					}
 					if (!reverse && keys.Count == count + 1)
 					{
@@ -329,7 +329,7 @@ public static async Task Map(string[] path, IFdbTuple extras, IFdbDatabase db, T
 				return;
 			}
 
-			var span = folder.DirectoryLayer.ContentSubspace.ToRange();
+			var span = folder.DirectoryLayer.ContentSubspace.Keys.ToRange();
 
 			// note: this may break in future versions of the DL! Maybe we need a custom API to get a flat list of all directories in a DL that span a specific range ?
 
@@ -554,7 +554,7 @@ public static async Task Shards(string[] path, IFdbTuple extras, IFdbDatabase db
 			var folder = (await TryOpenCurrentDirectoryAsync(path, db, ct)) as FdbDirectorySubspace;
 			if (folder != null)
 			{
-				var r = FdbKeyRange.StartsWith(folder.Copy().Key);
+				var r = FdbKeyRange.StartsWith(FdbSubspace.Copy(folder).Key);
 				Console.WriteLine("Searching for shards that intersect with /{0} ...", String.Join("/", path));
 				ranges = await Fdb.System.GetChunksAsync(db, r, ct);
 				Console.WriteLine("Found {0} ranges intersecting {1}:", ranges.Count, r);
@@ -589,7 +589,7 @@ public static async Task Sampling(string[] path, IFdbTuple extras, IFdbDatabase
 			FdbKeyRange span;
 			if (folder is FdbDirectorySubspace)
 			{
-				span = FdbKeyRange.StartsWith((folder as FdbDirectorySubspace).Copy());
+				span = FdbKeyRange.StartsWith(FdbSubspace.Copy(folder as FdbDirectorySubspace).Key);
 				log.WriteLine("Reading list of shards for /{0} under {1} ...", String.Join("/", path), FdbKey.Dump(span.Begin));
 			}
 			else

FdbShell/Program.cs

@@ -305,7 +305,7 @@ private static async Task MainAsync(string[] args, CancellationToken cancel)
 					var tokens = s.Trim().Split(new [] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
 					string cmd = tokens.Length > 0 ? tokens[0] : String.Empty;
 					string prm = tokens.Length > 1 ? tokens[1] : String.Empty;
-					var extras = tokens.Length > 2 ? FdbTuple.CreateRange<string>(tokens.Skip(2)) : FdbTuple.Empty;
+					var extras = tokens.Length > 2 ? FdbTuple.FromEnumerable<string>(tokens.Skip(2)) : FdbTuple.Empty;
 
 					var trimmedCommand = cmd.Trim().ToLowerInvariant();
 					switch (trimmedCommand)

FoundationDB.Client.sln

@@ -56,6 +56,11 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FdbTop", "FdbTop\FdbTop.csp
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FdbBurner", "FdbBurner\FdbBurner.csproj", "{60049BA1-A95F-4127-BAC5-74AF023D3082}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Documents", "Documents", "{1B6BEB71-8C92-4B06-9715-9DAF49907BA1}"
+	ProjectSection(SolutionItems) = preProject
+		Tuples.md = Tuples.md
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU

FoundationDB.Client/Async/AsyncCancellableMutex.cs

@@ -83,7 +83,7 @@ public AsyncCancelableMutex(CancellationToken ct)
 		{
 			if (ct.CanBeCanceled)
 			{
-				m_ctr = ct.Register(s_cancellationCallback, new WeakReference<AsyncCancelableMutex>(this), useSynchronizationContext: false);
+				m_ctr = ct.RegisterWithoutEC(s_cancellationCallback, new WeakReference<AsyncCancelableMutex>(this));
 			}
 			GC.SuppressFinalize(this);
 		}
@@ -130,12 +130,12 @@ public bool Abort(bool async = false)
 
 		private static void SetDefered(AsyncCancelableMutex mutex)
 		{
-			ThreadPool.QueueUserWorkItem((state) => ((AsyncCancelableMutex)state).TrySetResult(null), mutex);
+			ThreadPool.UnsafeQueueUserWorkItem((state) => ((AsyncCancelableMutex)state).TrySetResult(null), mutex);
 		}
 
 		private static void CancelDefered(AsyncCancelableMutex mutex)
 		{
-			ThreadPool.QueueUserWorkItem((state) => ((AsyncCancelableMutex)state).TrySetCanceled(), mutex);
+			ThreadPool.UnsafeQueueUserWorkItem((state) => ((AsyncCancelableMutex)state).TrySetCanceled(), mutex);
 		}
 
 	}

FoundationDB.Client/Async/TaskHelpers.cs

@@ -400,6 +400,36 @@ public static void Observe(Task task)
 			}
 		}
 
+		private delegate CancellationTokenRegistration RegisterWithoutECDelegate(ref CancellationToken ct, Action<object> callback, object state);
+		private static readonly RegisterWithoutECDelegate RegisterWithoutECHandler = GetRegisterWithoutECDelegate();
+
+		[NotNull]
+		private static RegisterWithoutECDelegate GetRegisterWithoutECDelegate()
+		{
+			try
+			{
+				// CancellationToken.Register(..., useExecutionContext) is "private", and all the public version of Register pass true, which does costly allocations (capturing context, ...)
+				// There is however CancellationToken.InternalRegisterWithoutEC which is internal and pass false.
+				// => we will attempt to create a delegate to call the internal method - if possible - or fallback to the default version of Register, if this is not possible.
+				var method = typeof(CancellationToken).GetMethod("InternalRegisterWithoutEC", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic, null, new[] { typeof(Action<object>), typeof(object) }, null);
+				if (method != null)
+				{
+					return (RegisterWithoutECDelegate)Delegate.CreateDelegate(typeof(RegisterWithoutECDelegate), null, method);
+				}
+			}
+			catch
+			{ }
+
+			return (ref CancellationToken token, Action<object> callback, object state) => token.Register(callback, state);
+		}
+
+		/// <summary>Version of CancellationToken.Register() that does not propagate the current ExecutionContext to the callback (faster, but unsafe!)</summary>
+		/// <remarks>This should only be used with callbacks that do not execute user-provided code!</remarks>
+		internal static CancellationTokenRegistration RegisterWithoutEC(this CancellationToken ct, [NotNull] Action<object> callback, object state)
+		{
+			return RegisterWithoutECHandler(ref ct, callback, state);
+		}
+
 		/// <summary>Safely cancel a CancellationTokenSource</summary>
 		/// <param name="source">CancellationTokenSource that needs to be cancelled</param>
 		public static void SafeCancel(this CancellationTokenSource source)

FoundationDB.Client/Core/IFdbTransactionHandler.cs

@@ -51,7 +51,8 @@ public interface IFdbTransactionHandler : IDisposable
 		void SetOption(FdbTransactionOption option, Slice data);
 
 		/// <summary>Returns this transaction snapshot read version.</summary>
-		Task<long> GetReadVersionAsync(CancellationToken cancellationToken);
+		/// <param name="cancellationToken">Token used to cancel the operation from the outside, if different than the cancellation token of the transaction itself</param>
+		Task<long> GetReadVersionAsync(CancellationToken cancellationToken = default(CancellationToken));
 
 		/// <summary>Retrieves the database version number at which a given transaction was committed.</summary>
 		/// <remarks>CommitAsync() must have been called on this transaction and the resulting task must have completed successfully before this function is callged, or the behavior is undefined.
@@ -71,46 +72,46 @@ public interface IFdbTransactionHandler : IDisposable
 		/// <summary>Reads a get from the database</summary>
 		/// <param name="key">Key to read</param>
 		/// <param name="snapshot">Set to true for snapshot reads</param>
-		/// <param name="cancellationToken"></param>
+		/// <param name="cancellationToken">Token used to cancel the operation from the outside, if different than the cancellation token of the transaction itself</param>
 		/// <returns></returns>
-		Task<Slice> GetAsync(Slice key, bool snapshot, CancellationToken cancellationToken);
+		Task<Slice> GetAsync(Slice key, bool snapshot, CancellationToken cancellationToken = default(CancellationToken));
 
 		/// <summary>Reads several values from the database snapshot represented by the current transaction</summary>
 		/// <param name="keys">Keys to be looked up in the database</param>
 		/// <param name="snapshot">Set to true for snapshot reads</param>
-		/// <param name="cancellationToken">Token used to cancel the operation from the outside</param>
+		/// <param name="cancellationToken">Token used to cancel the operation from the outside, if different than the cancellation token of the transaction itself</param>
 		/// <returns>Task that will return an array of values, or an exception. Each item in the array will contain the value of the key at the same index in <paramref name="keys"/>, or Slice.Nil if that key does not exist.</returns>
-		Task<Slice[]> GetValuesAsync([NotNull] Slice[] keys, bool snapshot, CancellationToken cancellationToken);
+		Task<Slice[]> GetValuesAsync([NotNull] Slice[] keys, bool snapshot, CancellationToken cancellationToken = default(CancellationToken));
 
 		/// <summary>Resolves a key selector against the keys in the database snapshot represented by the current transaction.</summary>
 		/// <param name="selector">Key selector to resolve</param>
 		/// <param name="snapshot">Set to true for snapshot reads</param>
-		/// <param name="cancellationToken">Token used to cancel the operation from the outside</param>
+		/// <param name="cancellationToken">Token used to cancel the operation from the outside, if different than the cancellation token of the transaction itself</param>
 		/// <returns>Task that will return the key matching the selector, or an exception</returns>
-		Task<Slice> GetKeyAsync(FdbKeySelector selector, bool snapshot, CancellationToken cancellationToken);
+		Task<Slice> GetKeyAsync(FdbKeySelector selector, bool snapshot, CancellationToken cancellationToken = default(CancellationToken));
 
 		/// <summary>Resolves several key selectors against the keys in the database snapshot represented by the current transaction.</summary>
 		/// <param name="selectors">Key selectors to resolve</param>
 		/// <param name="snapshot">Set to true for snapshot reads</param>
-		/// <param name="cancellationToken">Token used to cancel the operation from the outside</param>
+		/// <param name="cancellationToken">Token used to cancel the operation from the outside, if different than the cancellation token of the transaction itself</param>
 		/// <returns>Task that will return an array of keys matching the selectors, or an exception</returns>
-		Task<Slice[]> GetKeysAsync([NotNull] FdbKeySelector[] selectors, bool snapshot, CancellationToken cancellationToken);
+		Task<Slice[]> GetKeysAsync([NotNull] FdbKeySelector[] selectors, bool snapshot, CancellationToken cancellationToken = default(CancellationToken));
 
 		/// <summary>Reads all key-value pairs in the database snapshot represented by transaction (potentially limited by Limit, TargetBytes, or Mode) which have a key lexicographically greater than or equal to the key resolved by the begin key selector and lexicographically less than the key resolved by the end key selector.</summary>
 		/// <param name="beginInclusive">key selector defining the beginning of the range</param>
 		/// <param name="endExclusive">key selector defining the end of the range</param>
 		/// <param name="options">Optionnal query options (Limit, TargetBytes, Mode, Reverse, ...)</param>
 		/// <param name="iteration">If streaming mode is FdbStreamingMode.Iterator, this parameter should start at 1 and be incremented by 1 for each successive call while reading this range. In all other cases it is ignored.</param>
 		/// <param name="snapshot">Set to true for snapshot reads</param>
-		/// <param name="cancellationToken">Token used to cancel the operation from the outside</param>
+		/// <param name="cancellationToken">Token used to cancel the operation from the outside, if different than the cancellation token of the transaction itself</param>
 		/// <returns></returns>
-		Task<FdbRangeChunk> GetRangeAsync(FdbKeySelector beginInclusive, FdbKeySelector endExclusive, [NotNull] FdbRangeOptions options, int iteration, bool snapshot, CancellationToken cancellationToken);
+		Task<FdbRangeChunk> GetRangeAsync(FdbKeySelector beginInclusive, FdbKeySelector endExclusive, [NotNull] FdbRangeOptions options, int iteration, bool snapshot, CancellationToken cancellationToken = default(CancellationToken));
 
 		/// <summary>Returns a list of public network addresses as strings, one for each of the storage servers responsible for storing <paramref name="key"/> and its associated value</summary>
 		/// <param name="key">Name of the key whose location is to be queried.</param>
-		/// <param name="cancellationToken">Token used to cancel the operation from the outside</param>
+		/// <param name="cancellationToken">Token used to cancel the operation from the outside, if different than the cancellation token of the transaction itself</param>
 		/// <returns>Task that will return an array of strings, or an exception</returns>
-		Task<string[]> GetAddressesForKeyAsync(Slice key, CancellationToken cancellationToken);
+		Task<string[]> GetAddressesForKeyAsync(Slice key, CancellationToken cancellationToken = default(CancellationToken));
 
 		/// <summary>Modify the database snapshot represented by transaction to change the given key to have the given value. If the given key was not previously present in the database it is inserted.
 		/// The modification affects the actual database only if transaction is later committed with CommitAsync().
@@ -153,19 +154,19 @@ public interface IFdbTransactionHandler : IDisposable
 		/// The commit may or may not succeed – in particular, if a conflicting transaction previously committed, then the commit must fail in order to preserve transactional isolation. 
 		/// If the commit does succeed, the transaction is durably committed to the database and all subsequently started transactions will observe its effects.
 		/// </summary>
-		/// <param name="cancellationToken">Token used to cancel the operation from the outside</param>
+		/// <param name="cancellationToken">Token used to cancel the operation from the outside, if different than the cancellation token of the transaction itself</param>
 		/// <returns>Task that succeeds if the transaction was comitted successfully, or fails if the transaction failed to commit.</returns>
 		/// <remarks>As with other client/server databases, in some failure scenarios a client may be unable to determine whether a transaction succeeded. In these cases, CommitAsync() will throw CommitUnknownResult error. The OnErrorAsync() function treats this error as retryable, so retry loops that don’t check for CommitUnknownResult could execute the transaction twice. In these cases, you must consider the idempotence of the transaction.</remarks>
-		Task CommitAsync(CancellationToken cancellationToken);
+		Task CommitAsync(CancellationToken cancellationToken = default(CancellationToken));
 
 		/// <summary>Implements the recommended retry and backoff behavior for a transaction.
 		/// This function knows which of the error codes generated by other query functions represent temporary error conditions and which represent application errors that should be handled by the application. 
 		/// It also implements an exponential backoff strategy to avoid swamping the database cluster with excessive retries when there is a high level of conflict between transactions.
 		/// </summary>
 		/// <param name="code">FdbError code thrown by the previous command</param>
-		/// <param name="cancellationToken">Token used to cancel the operation from the outside</param>
+		/// <param name="cancellationToken">Token used to cancel the operation from the outside, if different than the cancellation token of the transaction itself</param>
 		/// <returns>Returns a task that completes if the operation can be safely retried, or that rethrows the original exception if the operation is not retryable.</returns>
-		Task OnErrorAsync(FdbError code, CancellationToken cancellationToken);
+		Task OnErrorAsync(FdbError code, CancellationToken cancellationToken = default(CancellationToken));
 
 		/// <summary>Reset transaction to its initial state.</summary>
 		/// <remarks>This is similar to disposing the transaction and recreating a new one.  The only state that persists through a transaction reset is that which is related to the backoff logic used by OnErrorAsync()</remarks>