fdbserver/StorageCache.actor.cpp (58 lines):
	- line 42: // TODO storageCache server shares quite a bit of storageServer functionality, although simplified
	- line 46: // TODO rename wrong_shard_server error to wrong_cache_server
	- line 156: // TODO change it to a deque, already contains mutations in version order
	- line 173: // TODO Add cache metrics, such as available memory/in-use memory etc to help dat adistributor assign cached ranges
	- line 189: // TODO double check which ones we need for storageCache servers
	- line 196: // TODO not really in use as of now. may need in some failure cases. Revisit and remove if no plausible use
	- line 203: // TODO do we need otherError here?
	- line 214: // TODO double check which ones we need for storageCache servers
	- line 283: // TODO: should we throw the cold_cache_server() error here instead?
	- line 294: // TODO: should we throw the cold_cache_server() error here instead?
	- line 323: // TODO find out more
	- line 349: // TODO revisit this check. there could be nodes in PTree that were inserted, but never updated. their
	- line 431: // FIXME: A bunch of these can block with or without the following delay 0.
	- line 473: // TODO later
	- line 479: // TODO what's this?
	- line 512: // TODO: do we need to check changeCounter here?
	- line 619: result.more = limit == 0 || *pLimitBytes <= 0; // FIXME: Does this have to be exact?
	- line 682: // FIXME: If range.begin=="" && !forward, return success?
	- line 927: // TODO check if the following is correct
	- line 1004: // TODO double check if the insert version of the previous clear needs to be preserved for the "left half",
	- line 1016: // TODO double check if it's okay to let go of the the insert version of the "right half"
	- line 1017: // FIXME: This copy is technically an asymptotic problem, definitely a waste of memory (copy of keyAfter
	- line 1074: // FIXME: enable when debugKeyRange is active
	- line 1077: // FIXME: It's not straightforward to rollback certain versions from the VersionedMap.
	- line 1248: // TODO  we should probably change this for cache server
	- line 1256: // FIXME: enable when debugKeyRange is active
	- line 1265: // TODO: double check the following block of code!!
	- line 1313: // FIXME: this should invalidate the location cache for cacheServers
	- line 1339: // FIXME: enable when debugKeyRange is active
	- line 1342: // FIXME: enable when debugMutation is active
	- line 1362: // TODO: If there was more to be fetched and we hit the limit before - possibly a case where data
	- line 1392: // TODO: NEELAM: what's this for?
	- line 1393: // FIXME: remove when we no longer support upgrades from 5.X
	- line 1422: // TODO revisit the following block of code
	- line 1428: // TODO: do we need this kind of wait? we are not going to make anything durable and hence no fear of wrong
	- line 1473: // FIXME: pass the deque back rather than copy the data
	- line 1480: // FIXME: enable when debugMutation is active
	- line 1487: // TODO: NEELAM: what exactly does it do? Writing some mutations to log. Do we need it for caches?
	- line 1492: // TODO: double check.
	- line 1512: // TODO define the shuttingDown state of cache server
	- line 1516: // TODO Not sure if it's okay to do this here!!
	- line 1581: else if (mutation.type != MutationRef::ClearRange) { // TODO NEELAM: ClearRange mutations are ignored (why do we
	- line 1594: // FIXME: enable when debugKeyRange is active
	- line 1741: // TODO Revisit during failure handling. Might we loose some private mutations?
	- line 1792: // TODO revisit if we change the data structure of the VersionedMap
	- line 1795: // TODO understand this, should we add delay here?
	- line 1807: // TODO not really in use as of now. may need in some failure cases. Revisit and remove if no plausible use
	- line 1814: // TODO It's a synchronous function call as of now. Should it asynch?
	- line 1820: // TODO how do we yield here? This may not be enough, because compact() does the heavy lifting
	- line 1825: // TODO what flowlock to acquire during compaction?
	- line 1884: // TODO cache servers should write the LogProtocolMessage when they are created
	- line 1955: // FIXME: ensure this can only read data from the current version
	- line 1972: // TODO should we store the logProtocol?
	- line 2036: // TODO what about otherError
	- line 2040: // TODO may enable these later
	- line 2045: // TODO double check
	- line 2048: // TODO what about otherError
	- line 2209: // TODO do we need to add throttling for cache servers? Probably not


fdbserver/BlobWorker.actor.cpp (53 lines):
	- line 49: // TODO add comments + documentation
	- line 94: // TODO get rid of this and do Reference<Standalone<GranuleDeltas>>?
	- line 128: // TODO: rename this struct
	- line 153: // FIXME: do skip pointers with single back-pointer and neighbor pointers
	- line 175: // FIXME: refactor out the parts of this that are just for interacting with blob stores from the backup business
	- line 182: // FIXME: expire from map after a delay when granule is revoked and the history is no longer needed
	- line 373: // TODO is this explicit conflit range necessary with the above read?
	- line 446: // FIXME: enable
	- line 497: // TODO some sort of directory structure would be useful?
	- line 504: // FIXME: technically we can free up deltaArena here to reduce memory
	- line 600: // TODO some sort of directory structure would be useful maybe?
	- line 631: // TODO REMOVE sanity checks!
	- line 645: // TODO is this easy to read as a flatbuffer from reader? Need to be sure about this data format
	- line 655: // TODO: inject write error
	- line 749: // TODO: use streaming range read
	- line 750: // TODO: inject read error
	- line 751: // TODO knob for limit?
	- line 843: // TODO: inject read error
	- line 918: // FIXME: for a write-hot shard, we could potentially batch these and only pop the largest one after several
	- line 920: // FIXME: also have these be async, have each pop change feed wait on the prior one, wait on them before
	- line 932: // FIXME: is this the correct set of errors?
	- line 1005: // FIXME: could binary search?
	- line 1054: // TODO: this is getting kind of large. Should try to split out this actor if it continues to grow?
	- line 1055: // FIXME: handle errors here (forward errors)
	- line 1164: // FIXME: once we have empty versions, only include up to startState.changeFeedStartVersion in the read
	- line 1168: // FIXME: filtering on key range != change feed range doesn't work
	- line 1228: // TODO filter old mutations won't be necessary, SS does it already
	- line 1324: // FIXME: if we're still reading from old change feed, we should probably compact if we're making a
	- line 1418: // TODO: this could read from FDB instead if it knew there was a large range clear at the end or
	- line 1470: // FIXME: THIS IS FALSE!! delta can commit by getting committed version out of band, without
	- line 1481: // FIXME: add counter for granule rollbacks and rollbacks skipped?
	- line 1626: // FIXME: not true for merges
	- line 1662: // FIXME: not true for merges
	- line 1702: // TODO this should never happen?
	- line 1708: // TODO might want to separate this out for valid values for range assignments vs read requests. Assignment conflict
	- line 1782: // TODO REMOVE in api V2
	- line 1825: // FIXME: this will get more complicated with merges where this could potentially include partial
	- line 1850: // FIXME: doesn't work once we add granule merging, could be multiple ranges and/or multiple parents
	- line 1852: // FIXME: use skip pointers here
	- line 1859: // FIXME: probably want a dedicated exception like blob_range_too_old or something instead
	- line 1916: // TODO change in V2
	- line 1921: // TODO refactor the "find snapshot file" logic to GranuleFiles?
	- line 1922: // FIXME: binary search instead of linear search, especially when file count is large
	- line 1964: // FIXME: do trivial key bounds here if key range is not fully contained in request key range
	- line 2075: // FIXME: use actual 16 bytes of UID instead of converting it to 32 character string and then that
	- line 2083: // FIXME: could avoid max uid for granule ids here
	- line 2099: // TODO change this for merge
	- line 2188: // FIXME: original Epoch/Seqno is now not necessary with originalReq
	- line 2206: // TODO unit test this assignment, particularly out-of-order insertions!
	- line 2441: // FIXME: retry on error if dispose fails?
	- line 2468: wait(delay(0.1)); // TODO KNOB?
	- line 2555: // TODO: pick a reasonable byte limit instead of just piggy-backing
	- line 2631: // TODO add unit tests for assign/revoke range, especially version ordering


fdbserver/storageserver.actor.cpp (31 lines):
	- line 1297: // FIXME: A bunch of these can block with or without the following delay 0.
	- line 1990: } // FIXME: check that this is triggered when the range is moved to a different
	- line 1994: when(wait(delay(5.0))) {} // TODO REMOVE this once empty version logic is fully implemented
	- line 2143: // TODO: Use a lower level API may be better? Or tweak priorities?
	- line 2165: // TODO: is DefaultPromiseEndpoint the best priority for this?
	- line 2168: // TODO: async in case it needs to read from other servers.
	- line 2373: result.more = limit == 0 || *pLimitBytes <= 0; // FIXME: Does this have to be exact?
	- line 2463: // FIXME: If range.begin=="" && !forward, return success?
	- line 2612: m.iosPerKSecond = 1; //FIXME: this should be 1/r.data.size(), but we cannot do that because it is an int
	- line 2669: // TODO: Use a lower level API may be better? Or tweak priorities?
	- line 2698: // TODO: is DefaultPromiseEndpoint the best priority for this?
	- line 2701: // TODO: async in case it needs to read from other servers.
	- line 2932: // TODO: Shall we throw exception if the key doesn't exist or the range is empty?
	- line 3061: // TODO: Only mapped keys are returned, which are not supposed to be in the range.
	- line 3064: // TODO: GetKeyValuesWithFlatMapRequest doesn't respect limit yet.
	- line 3071: m.iosPerKSecond = 1; //FIXME: this should be 1/r.data.size(), but we cannot do that because it is an int
	- line 3248: m.iosPerKSecond = 1; //FIXME: this should be 1/r.data.size(), but we cannot do that because it is an
	- line 3665: // FIXME: This copy is technically an asymptotic problem, definitely a waste of memory (copy of keyAfter
	- line 4203: // FIXME: The client cache does not notice when servers are added to a team. To read from a local storage server
	- line 4293: // FIXME: remove when we no longer support upgrades from 5.X
	- line 4342: // FIXME: remove when we no longer support upgrades from 5.X
	- line 4387: // shard->transferredVersion = batch->changes[0].version;  //< FIXME: This obeys the documented properties, and
	- line 4414: // FIXME: pass the deque back rather than copy the data
	- line 4760: // FIXME: This code is relying for liveness on an undocumented property of the log system implementation: that after
	- line 4823: // FIXME: enable when DEBUG_MUTATION is active
	- line 5065: // TODO revisit- we are not splitting the cached ranges based on shards as of now.
	- line 6105: // TODO: why is this seemingly random delay here?
	- line 6297: // FIXME: instead of using random chance, send wrong_shard_server when the call in from
	- line 6498: // TODO: Is it fine to keep TransactionLineage::Operation::GetKeyValues here?
	- line 6515: // FIXME: add readGuard again
	- line 6631: // TODO: fast load balancing?


fdbserver/VersionedBTree.actor.cpp (29 lines):
	- line 1229: Error e = internal_error(); // TODO:  Something better?
	- line 2187: // TODO: How should this cache be sized - not really a cache. it should hold all extentIDs?
	- line 2223: // TODO:  If the file exists but appears to never have been successfully committed is this an error or
	- line 2243: // TODO: Detect if process is being restarted and only throw injected if so?
	- line 2359: // TODO:  Is the right behavior?
	- line 2467: self->extentUsedList.numEntries); // TODO this is overreserving. is that a problem?
	- line 2504: // TODO: This is abstraction breaking.  This should probably be stored as a member, calculated once on construction
	- line 2734: // TODO:  Possibly limit size of remap queue since it must be recovered on cold start
	- line 2889: // TODO:  Could a dispatched read try to write to page after it has been destroyed if this actor is cancelled?
	- line 2937: // TODO:  Could a dispatched read try to write to page after it has been destroyed if this actor is cancelled?
	- line 3875: // TODO: Make this an ordered container some day.
	- line 3897: // TODO: Better data structure
	- line 3979: // TODO: Move this to a flow header once it is mature.
	- line 4155: // TODO: Use SplitStringRef (unless it ends up being slower)
	- line 4840: // TODO: Is it contractually okay to always to read at the latest version?
	- line 4941: // TODO: Get actual max MetaKey size limit from Pager
	- line 5259: * TODO: A possible optimization here could be to only use existing btree leaf page boundaries as keys,
	- line 5591: // TODO: Avoid copying page bytes, but this is not trivial due to how pager checksums are currently handled.
	- line 6020: // TODO: insert recs in a random order to avoid new subtree being entirely right child links
	- line 6184: // TODO:  Decide if it is okay to update if the subtree boundaries are expanded.  It can result in
	- line 6571: u.skipLen = 0; // TODO: set this
	- line 6604: // TODO:  If cursor hints are available, use (cursor, 1)
	- line 6619: u.skipLen = 0; // TODO: set this
	- line 9072: // TODO:  Once seekLessThanOrEqual() with a hint is as fast as seekLessThanOrEqualOld, remove it.
	- line 9600: // TODO: Verify reads, do more writes and reads to make this a real pager validator
	- line 10005: // TODO there is probably a better way to do this
	- line 10080: // TODO unused, remove?
	- line 10211: // TODO is it desired that not all records are committed? This could commit again to ensure any records set() since
	- line 10430: // TODO change to 100e8 after figuring out no-disk redwood mode


fdbclient/NativeAPI.actor.cpp (26 lines):
	- line 215: // FIXME: load balance holds pointers to individual members of the interface, and this assignment will
	- line 432: // TODO could skip this whole thing if tss if request counter is zero?
	- line 778: // TODO: this needs to be more clever in the future
	- line 2526: // FIXME: these shards are being inserted into the map sequentially, it would be much more CPU
	- line 2939: // FIXME: wait for known committed version on the storage server before replying,
	- line 3191: // FIXME: buggify byte limits on internal functions that use them, instead of globally
	- line 3394: // TODO: Client should add mapped keys to conflict ranges.
	- line 3475: // FIXME: Is this really right?  Weaken this and see if there is a problem;
	- line 3820: // FIXME: this code is pretty much identical to LoadBalance.h
	- line 3821: // TODO could add team check logic in if we added synchronous way to turn this into a fixed getRange request
	- line 3884: // FIXME: optimize to avoid creating new netNotifiedQueueWithAcknowledgements for each stream duplication
	- line 3927: // FIXME: buggify byte limits on internal functions that use them, instead of globally
	- line 3948: // FIXME: create a load balance function for this code so future users of reply streams do not have
	- line 4177: // FIXME: better handling to disable row limits
	- line 4191: // FIXME: this conflict range is too large, and should be updated continously as results are returned
	- line 4414: // FIXME: This seems pretty horrible. Now a Database can't die until all of its watches do...
	- line 4651: // FIXME: limits are not implemented yet, and this code has not be tested with reverse=true
	- line 5956: if (maxThrottleDelay > 0.0 && !canRecheck) { // TODO: allow delaying?
	- line 6277: // TODO: how to handle this?
	- line 6501: // FIXME: use streaming range read
	- line 6563: // FIXME: eventually we probably want to cache this and invalidate similarly to storage servers.
	- line 6598: // TODO probably new exception type instead
	- line 6616: // FIXME: maybe just want to insert here if there are racing queries for the same worker or something?
	- line 6758: false); // FIXME: This seems impossible and doesn't seem to be covered by testing
	- line 7326: // FIXME: create a load balance function for this code so future users of reply streams do not have
	- line 7604: // FIXME: lookup both the src and dest shards as of the pop version to ensure all locations are popped


fdbserver/BlobManager.actor.cpp (17 lines):
	- line 41: // FIXME: change all BlobManagerData* to Reference<BlobManagerData> to avoid segfaults if core loop gets error
	- line 43: // TODO add comments + documentation
	- line 103: // FIXME: could change this to O(N) instead of O(NLogN) by doing a sorted merge instead of requesting the
	- line 193: // TODO: track worker's reads/writes eventually
	- line 229: // TODO is it better to just pass empty metrics to estimated?
	- line 362: // TODO confirm: using reliable delivery this should only trigger if the worker is marked as failed, right?
	- line 382: // FIXME: improvement would be to add history of failed workers to assignment so it can try other ones first
	- line 443: // FIXME: if range is assign, have some sort of semaphore for outstanding assignments so we don't assign
	- line 492: // FIXME: this does all logic in one transaction. Adding a giant range to an existing database to blobify would
	- line 506: // TODO probably knobs here? This should always be pretty small though
	- line 793: // TODO maybe this won't be true eventually, but right now the only time the blob worker reports back is
	- line 834: // FIXME: this could throw connection_failed and we could handle catch this the same as the failure
	- line 844: // TODO change back from SevError?
	- line 875: // FIXME: forward errors somewhere from here
	- line 879: // TODO change back from SevError?
	- line 924: // FIXME: with low probability, could immediately revoke it from the new assignment and move it back
	- line 1134: // TODO probably other things here eventually


fdbserver/sqlite/sqlite3.amalgamation.c (16 lines):
	- line 393: /* FIXME: this needs to be true for better tracking memory use in our
	- line 1188: /* TODO: This definition is just included so other modules compile. It
	- line 31482: ** TODO: This function allocates a single block of memory to load
	- line 31608: /* TODO: Is it safe to use Pager.dbFileSize here? */
	- line 31745: ** TODO: Technically the following is an error because it assumes that
	- line 34307: /* TODO: Check if all of these are really required. */
	- line 50860: ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
	- line 64044: ** TODO:  Add a test to make sure that the same column is not named
	- line 66108: /* TODO: Could use temporary registers here. Also could attempt to
	- line 67933: ** TODO: How should dropping a table be handled? How should renaming a
	- line 72272: /* TODO: Maybe it shouldn't be possible to change the ReadUncommitted
	- line 96375: ** database. TODO: For xConnect(), it could verify that said tables exist.
	- line 97403: ** buffer using memcpy(). TODO: Add a way to transfer control of the
	- line 99985: ** TODO: Strangely, it is not possible to associate a column specifier
	- line 104461: int nDummy; /* TODO: Remove this */
	- line 110602: // TODO:  Do something to read and initialize the database in case


fdbserver/SimulatedCluster.actor.cpp (16 lines):
	- line 58: // TODO: Defining these here is just asking for ODR violations.
	- line 1325: // TODO: Figure out what is broken with the RocksDB engine in simulation.
	- line 1388: // FIXME: log replicas must be more than storage replicas because otherwise better master exists will not
	- line 1465: // FIXME: we cannot use one satellite replication with more than one satellite per region because
	- line 1492: // FIXME: implement
	- line 1543: // FIXME: implement
	- line 2062: // FIXME: test unset dcID
	- line 2077: // FIXME: temporarily code to test storage cache
	- line 2078: // TODO: caching disabled for this merge
	- line 2116: // FIXME: temporarily code to test storage cache
	- line 2117: // TODO: caching disabled for this merge
	- line 2197: // FIXME: Start workers with tester class instead, at least sometimes run tests with the testers-only flag
	- line 2279: // TODO: Currently backup and restore related simulation tests are failing when run with rocksDB storage engine
	- line 2300: // TODO (IPv6) Use IPv6?
	- line 2332: // FIXME: snapshot restore does not support multi-region restore, hence restore it as single region always
	- line 2346: wait(delay(1.0)); // FIXME: WHY!!!  //wait for machines to boot


fdbserver/Status.actor.cpp (13 lines):
	- line 361: // FIXME: this will not catch if the secondary address of the process was excluded
	- line 494: try { // FIXME: This field was added in a patch release, the try-catch can be removed for the 7.0 release
	- line 1222: // TODO:  time_in_recovery: 0.5
	- line 1666: // TODO:  Should this be serial?
	- line 1710: // TODO: moving_data["rate_bytes"] = makeCounter(hz, c, r);
	- line 1959: // FIXME: does not take into account fallback satellite policies
	- line 2216: // FIXME: This field was added in a patch release, for the 7.0 release move this to above loop
	- line 2346: // FIXME: This hack to bump satellite fault tolerance, is to make it consistent
	- line 2497: // FIXME: name and description will be the same unless the message is 'incorrect_cluster_file_contents', which is
	- line 2544: // FIXME: add the log_group in addition to the network address
	- line 2581: // TODO:  Also fetch other linked subtrees of meta keys
	- line 2968: // TODO: Read from coordinators for more up-to-date config database status?
	- line 2980: // TODO:  This probably is no longer possible as there is no ability to merge json objects with an


fdbserver/TLogServer.actor.cpp (11 lines):
	- line 746: // FIXME: push shouldn't return anything.  We should call getNextPushLocation() again.
	- line 1114: // FIXME: Maintain a heap of tags ordered by version to make this O(1) instead of O(n).
	- line 1265: // FIXME: This policy for calculating the cache pop version could end up popping recent data in the remote DC after
	- line 1781: // FIXME: Limit to approximately DESIRED_TOTATL_BYTES somehow.
	- line 2413: // FIXME: Add the knownCommittedVersion to this message and change ratekeeper to use that version.
	- line 2571: // FIXME: As part of reverting snapshot V1, make ignorePopUid a UID instead of string
	- line 2783: // FIXME: update tlogMetrics to include new information, or possibly only have one copy for the shared instance
	- line 2883: // FIXME: metadata in queue?
	- line 2900: // FIXME: remove when we no longer need to test upgrades from 4.X releases
	- line 3395: // TODO: This should fully spill, but currently doing so will cause us to no longer update poppedVersion
	- line 3582: int removedElements = 0; // deterministicRandom()->randomInt(0, numElements); // FIXME: the overhead factor


fdbserver/OldTLogServer_6_2.actor.cpp (11 lines):
	- line 718: // FIXME: push shouldn't return anything.  We should call getNextPushLocation() again.
	- line 1083: // FIXME: Maintain a heap of tags ordered by version to make this O(1) instead of O(n).
	- line 1132: // FIXME: This policy for calculating the cache pop version could end up popping recent data in the remote DC after
	- line 1734: // FIXME: Limit to approximately DESIRED_TOTATL_BYTES somehow.
	- line 2329: // FIXME: Add the knownCommittedVersion to this message and change ratekeeper to use that version.
	- line 2488: // FIXME: As part of reverting snapshot V1, make ignorePopUid a UID instead of string
	- line 2698: // FIXME: update tlogMetrics to include new information, or possibly only have one copy for the shared instance
	- line 2781: // FIXME: metadata in queue?
	- line 2788: // FIXME: remove when we no longer need to test upgrades from 4.X releases
	- line 3274: // TODO: This should fully spill, but currently doing so will cause us to no longer update poppedVersion
	- line 3409: int removedElements = 0; // deterministicRandom()->randomInt(0, numElements); // FIXME: the overhead factor


fdbserver/workloads/ConsistencyCheck.actor.cpp (10 lines):
	- line 132: self->quiescentWaitTimeout)); // FIXME: should be zero?
	- line 261: if (maxTLogQueueInfo.first > 1e5) // FIXME: Should be zero?
	- line 345: .error(e); // FIXME: consistency check does not retry in this case
	- line 513: // TODO: in the future, run a check based on estimated data size like the existing storage servers'
	- line 1602: // FIXME: Where is this intended to be used?
	- line 1819: // TODO could improve this check by also ensuring DD is currently recruiting a TSS by using quietdb?
	- line 1923: // FIXME: this is hiding the fact that we can recruit a new storage server on a location the has
	- line 2012: /* TODO: replace above code with this once blob manager recovery is handled
	- line 2178: // FIXME: g_simulator.datacenterDead could return false positives. Relaxing checks until it is fixed.
	- line 2387: // TODO: Check Tlog


fdbserver/OldTLogServer_6_0.actor.cpp (9 lines):
	- line 922: // FIXME: This policy for calculating the cache pop version could end up popping recent data in the remote DC after
	- line 1884: // FIXME: Add the knownCommittedVersion to this message and change ratekeeper to use that version.
	- line 2043: // FIXME: As part of reverting snapshot V1, make ignorePopUid a UID instead of string
	- line 2238: // FIXME: update tlogMetrics to include new information, or possibly only have one copy for the shared instance
	- line 2314: // FIXME: metadata in queue?
	- line 2320: // FIXME: remove when we no longer need to test upgrades from 4.X releases
	- line 2348: // FIXME: need for upgrades from 5.X to 6.0, remove once this upgrade path is no longer needed
	- line 2783: // TODO: This should fully spill, but currently doing so will cause us to no longer update poppedVersion
	- line 2921: int removedElements = 0; // deterministicRandom()->randomInt(0, numElements); // FIXME: the overhead factor


fdbclient/ReadYourWrites.actor.cpp (9 lines):
	- line 191: // FIXME: Optimistically assume that this will not run into the system keys, and only reissue if the result
	- line 221: // FIXME: Optimistically assume that this will not run into the system keys, and only reissue if the result
	- line 427: it.skip(key.getKey()); // TODO: or precondition?
	- line 472: key.setKey(maxKey); // maxKey is a KeyRef, but points to a LiteralStringRef. TODO: how can we ASSERT this?
	- line 593: // TODO: read to begin, read through end flags for result
	- line 767: // TODO: Is there a more efficient way to deal with invalidation?
	- line 1077: // TODO: Is there a more efficient way to deal with invalidation?
	- line 2104: // TODO : Rewrite related code using C api
	- line 2138: // TODO: check transaction size here


fdbserver/RestoreController.actor.cpp (8 lines):
	- line 40: // TODO: Support [[maybe_unused]] attribute for actors
	- line 80: // TODO: Support [[maybe_unused]] attribute for actors
	- line 258: // TODO: Sanity check restoreRequests' key ranges do not overlap
	- line 268: // TODO: Initialize controllerData and all loaders and appliers' data for each restore request!
	- line 437: // TODO: Allow empty files in version batch; Filter out them here.
	- line 597: // TODO: Allow loading both range and log files in parallel
	- line 1144: // TODO: Replace the heartbeat mechanism with FDB failure monitoring mechanism
	- line 1151: state std::vector<Future<RestoreCommonReply>> fReplies(numRoles, Never()); // TODO: Reserve memory for this vector


fdbserver/worker.actor.cpp (8 lines):
	- line 1175: // FIXME:  This will not work correctly in simulation as all workers would share the same roles map
	- line 1289: // TODO: `issues` is right now only updated by `monitorTraceLogIssues` and thus is being `set` on every update.
	- line 1484: // FIXME: Error handling
	- line 1495: // TODO might be more efficient to mark a boolean on DiskStore in getDiskStores, but that kind of breaks
	- line 1581: // FIXME: Shouldn't if logData.first isValid && !isReady, shouldn't we
	- line 1947: // FIXME: start role for every tlog instance, rather that just for the shared actor, also use a
	- line 2233: // FIXME: this whole thing
	- line 2631: // FIXME: Initializing here causes simulation issues, these must be fixed


fdbserver/DiskQueue.actor.cpp (8 lines):
	- line 223: // FIXME: let the caller pass in where to write the data.
	- line 242: free); // TODO: we could potentially do better in the available field by accounting for the
	- line 298: // FIXME: Merge this function with IAsyncFileSystem::incrementalDeleteFile().
	- line 874: // FIXME: Is setting lastCommittedSeq to -1 instead of 0 necessary?
	- line 916: // FIXME: Remove this ASSERT when popping into uncommitted pages is fixed
	- line 990: // FIXME: getNextReadLocation should ASSERT( initialized ), but the memory storage engine needs
	- line 1123: memset(static_cast<void*>(&p), 0, sizeof(Page)); // FIXME: unnecessary?
	- line 1186: // FIXME I think there's something with nextReadLocation we can do here when initialized && !recovered.


fdbserver/DataDistribution.actor.cpp (7 lines):
	- line 660: std::map<UID, Reference<TCServerInfo>> server_and_tss_info; // TODO could replace this with an efficient way to do a read-only concatenation of 2 data structures?
	- line 1175: // FIXME: This code logic can be simplified.
	- line 2914: // FIXME: add remove support to localitySet so we do not have to recreate it
	- line 3260: // TODO: re-enable the following logging or remove them.
	- line 5480: // TODO would it be better to put all of them in primary DC?
	- line 5490: // FIXME: Should log this if the recruit count stays the same but the other numbers update?
	- line 5665: // FIXME: better way to do this than timer?


fdbclient/BlobGranuleReader.actor.cpp (7 lines):
	- line 33: // TODO more efficient data structure besides std::map? PTree is unecessary since this isn't versioned, but some other
	- line 37: // TODO could refactor the file reading code from here and the delta file function into another actor,
	- line 60: // TODO: improve the interface of this function so that it doesn't need
	- line 63: // FIXME: probably want to chunk this up with yields to avoid slow task for blob worker re-snapshotting by calling the
	- line 71: // TODO REMOVE with V2 of protocol
	- line 114: // TODO probably should add things like limit/bytelimit at some point?
	- line 119: // TODO for large amount of chunks, this should probably have some sort of buffer limit like ReplyPromiseStream.


fdbclient/BlobGranuleFiles.cpp (7 lines):
	- line 29: // FIXME: implement actual proper file format for this
	- line 43: // TODO REMOVE sanity check eventually
	- line 157: // TODO REMOVE sanity check
	- line 175: // TODO REMOVE with V2 of protocol
	- line 183: // FIXME: probably some threshold of a small percentage of the data is actually changed, where it makes sense to
	- line 221: // FIXME: could submit multiple chunks to start_load_f in parallel?
	- line 281: // FIXME: re-enable test!


fdbserver/RestoreLoader.actor.cpp (6 lines):
	- line 110: // TODO: Pop old requests whose version batch <= finishedBatch.get()
	- line 147: // TODO: Revisit if we should have (self->inflightSendingReqs > 0 && self->inflightLoadingReqs > 0)
	- line 564: // TODO: Sanity check the log file's range is overlapped with the restored version range
	- line 605: // TODO: Make the actor priority lower than sendMutation priority. (Unsure it will help performance though)
	- line 642: sampleBatch.push_back_deep(sampleBatch.arena(), samples[i]); // TODO: may not need deep copy
	- line 950: // TODO: Sanity check each asset has been received exactly once!


fdbclient/PaxosConfigTransaction.actor.cpp (6 lines):
	- line 202: // TODO: Load balance
	- line 214: // TODO: Load balance
	- line 228: // TODO: Load balance
	- line 248: // TODO: Improve this:
	- line 393: // TODO: Support using this option to determine atomicity
	- line 401: // TODO: Implement someday


fdbserver/workloads/BackupAndParallelRestoreCorrectness.actor.cpp (6 lines):
	- line 353: // TODO: Enable this function in correctness test
	- line 374: // TODO: Change to my restore agent code
	- line 501: printf("TODO: Check if restore can succeed if dirty restore is performed first\n");
	- line 502: // TODO: To support restore even after we attempt dirty restore. Not implemented in the 1st version
	- line 580: // TODO: Consider gracefully abort a restore and restart.
	- line 594: // TODO: Not Implemented yet


fdbserver/workloads/BlobGranuleVerifier.actor.cpp (6 lines):
	- line 68: // FIXME: don't do the delay in setup, as that delays the start of all workloads
	- line 105: // FIXME: run the actual FDBCLI command instead of copy/pasting its implementation
	- line 185: // FIXME: typedef this pair type and/or chunk list
	- line 338: // TODO: add debugging info for when this is a failure
	- line 351: // TODO: bias for immediately re-reading to catch rollback cases
	- line 454: // FIXME: add above as details


fdbserver/TagPartitionedLogSystem.actor.cpp (6 lines):
	- line 512: // FIXME: Randomize request order as in LegacyLogSystem?
	- line 1219: // FIXME: do this merge on one of the logs in the other data center to avoid sending multiple copies
	- line 1291: // FIXME: do this merge on one of the logs in the other data center to avoid sending multiple copies
	- line 1334: int8_t popLocality) { // FIXME: do not need to pop all generations of old logs
	- line 1397: popActors.add(popFromLog(this, log, tag, 1.0)); //< FIXME: knob
	- line 2982: // FIXME: we can remove this wait once we are able to have log routers which can ship data to the remote


fdbclient/FileBackupAgent.actor.cpp (5 lines):
	- line 2235: Params.beginVersion().set(task, 1); // FIXME: remove in 6.X, only needed for 5.2 backward compatibility
	- line 2900: // TODO:  Validate that the range version map has exactly the restored ranges in it.  This means that for any
	- line 3508: // TODO:  Check to see if there is a leak in the FutureBucket since an invalid task (validation key fails) will
	- line 4320: // TODO: register watch first and then check if the key exist
	- line 4509: // TODO: Get rid of all of these confusing boolean flags


fdbclient/BackupContainerFileSystem.actor.cpp (5 lines):
	- line 37: // TODO:  Do this more efficiently, as the range file list for a snapshot could potentially be hundreds of
	- line 613: // TODO:  Somehow check / report if the restorable range is not or may not be contiguous.
	- line 973: // TODO: Reenable the sanity check after TooManyFiles error is resolved
	- line 997: // FIXME: check if there are tagged logs. for each tag, there is no version gap.
	- line 1500: // TODO: refactor to not duplicate IBackupContainer::openContainer. It's the exact same


fdbclient/S3BlobStore.actor.cpp (5 lines):
	- line 93: // TODO: For backward compatibility because request_timeout was renamed to request_timeout_min
	- line 775: // TODO:  Add more error types?
	- line 1198: // TODO:  If this actor is used to send large files then combine the summing and packetization into a loop with a
	- line 1314: // TODO:  In the event that the client times out just before the request completes (so the client is unaware) then
	- line 1366: // TODO:  In the event that the client times out just before the request completes (so the client is unaware) then


fdbclient/DatabaseConfiguration.cpp (5 lines):
	- line 60: // FIXME: Sanity checking
	- line 572: // TODO:  Remove this once Redwood works as a log engine
	- line 576: // TODO:  Remove this once memroy radix tree works as a log engine
	- line 662: // FIXME: More efficient
	- line 750: // TODO: revisit all const_cast usages


fdbserver/tester.actor.cpp (5 lines):
	- line 393: // FIXME: Other stuff not filled in; why isn't this constructed here and passed down to the other
	- line 880: // FIXME: stop if one of the above phases throws an exception
	- line 1355: // TODO: replace with toml_parse_error();
	- line 1424: state Future<Void> ccMonitor = monitorServerDBInfo(cc, LocalityData(), dbInfo); // FIXME: locality
	- line 1719: reportErrors(monitorServerDBInfo(cc, LocalityData(), db), "MonitorServerDBInfo")); // FIXME: Locality


fdbservice/FDBService.cpp (5 lines):
	- line 201: // FIXME: should this be other than 0? Should we care if this fails?
	- line 225: exitCode = 2181; // FIXME: WHAT?
	- line 338: // FIXME: log error
	- line 449: // FIXME: Check that eventCount < MAXIMUM_WAIT_OBJECTS, here and/or in loadConf
	- line 451: // FIXME: Is 'fileChangeHandle' signalling each time around the loop?


fdbserver/ClusterController.actor.h (5 lines):
	- line 1315: // FIXME: This logic will fallback unnecessarily when usable dcs > 1 because it does not check all combinations of
	- line 1359: // FIXME: If remote DC is used as satellite then this logic only ensures that required number of remote
	- line 1583: // FIXME: TLog recruitment process does not guarantee the best fit is not worsened.
	- line 2158: // FIXME: The logic to pick a satellite in a remote region is not
	- line 2318: // FIXME: determine when to fail the cluster controller when a primaryDC has not been set


fdbserver/PaxosConfigConsumer.actor.cpp (5 lines):
	- line 78: // TODO: Load balance over quorum. Also need to catch
	- line 138: // TODO: We need to wait for all the responses to come in
	- line 250: // TODO: Load balance
	- line 282: // TODO: Load balance to avoid always hitting the
	- line 301: // TODO: Catch error_code_process_behind and retry with


fdbserver/KeyValueStoreRocksDB.actor.cpp (4 lines):
	- line 67: // TODO: Test background error in simulation. RocksDB doesn't use flow IO in simulation, which limits our ability to
	- line 149: // TODO: Add a knob for the block cache size. (Default is 8 MB)
	- line 155: // TODO: Make a knob for this as well.
	- line 1028: // TODO: Adapt the simulation framework to not advance time quickly when background reads/writes are occurring.


fdbserver/ConfigNode.actor.cpp (4 lines):
	- line 204: // TODO: Reenable this when running the ConfigIncrement workload with reboot=false
	- line 245: // TODO: Also send information about highest seen version
	- line 272: // TODO: Currently it is possible that extra configuration classes may be returned, we
	- line 313: // FIXME: Filtering after reading from disk is very inefficient


fdbserver/Ratekeeper.actor.cpp (4 lines):
	- line 37: unlimited, // TODO: rename to workload?
	- line 115: // FIXME: this is a tacky workaround for a potential uninitialized use in trackStorageServerQueueInfo
	- line 132: // FIXME: this is a tacky workaround for a potential uninitialized use in trackTLogQueueInfo (copied from
	- line 1295: if (targetRateRatio < .75) //< FIXME: KNOB for 2.0


flow/Platform.actor.cpp (4 lines):
	- line 2060: // FIXME: SevWarnAlways trace if "close" to out of memory
	- line 2179: // FIXME: We cannot inject faults after renaming the file, because we could end up with two asyncFileNonDurable
	- line 2470: // TODO:  Not resolving symbolic links does not yet behave well on Windows because of drive letters
	- line 2806: // TODO: Should this just truncate?


fdbrpc/AsyncFileWinASIO.actor.h (4 lines):
	- line 47: // FIXME: This implementation isn't actually asynchronous - it just does operations synchronously!
	- line 175: // FIXME: Possibly use SetFileInformationByHandle( file.native_handle(), FileEndOfFileInfo, ... ) instead
	- line 183: // FIXME: Do FlushFileBuffers in a worker thread (using g_network->createThreadPool)?
	- line 189: // FIXME: MoveFileEx(..., MOVEFILE_WRITE_THROUGH) in thread?


fdbserver/DataDistributionQueue.actor.cpp (4 lines):
	- line 599: // FIXME: is the merge case needed
	- line 897: // FIXME: we need spare capacity even when we're just going to be cancelling work via TEAM_HEALTHY
	- line 1123: // FIXME: do not add data in flight to servers that were already in the src.
	- line 1718: if (e.code() != error_code_broken_promise && // FIXME: Get rid of these broken_promise errors every time we are


fdbclient/ServerKnobs.cpp (4 lines):
	- line 152: init( MIN_SHARD_BYTES,                                  50000000 ); if( buggifySmallShards ) MIN_SHARD_BYTES = 40000; if (simulationMediumShards) MIN_SHARD_BYTES = 200000; //FIXME: data distribution tracker (specifically StorageMetrics) relies on this number being larger than the maximum size of a key value pair
	- line 562: //FIXME: Low priority reads are disabled by assigning very high knob values, reduce knobs for 7.0
	- line 583: init( MAX_TL_SS_VERSION_DIFFERENCE,                         1e99 ); // if( randomize && BUGGIFY ) MAX_TL_SS_VERSION_DIFFERENCE = std::max(1.0, 0.25 * VERSIONS_PER_SECOND); // spring starts at half this value //FIXME: this knob causes ratekeeper to clamp on idle cluster in simulation that have a large number of logs
	- line 801: init( BG_URL,                                                 "" ); // TODO: store in system key space, eventually


fdbrpc/sim2.actor.cpp (4 lines):
	- line 868: deterministicRandom()->random01() < 0.25) { // FIXME: why doesnt this work when we are changing machines?
	- line 1230: // FIXME: Sometimes, connections to/from this process will explicitly close
	- line 2449: FIXME: Use an actual platform abstraction for this stuff!  Is there any reason we can't use underlying net2 for
	- line 2554: // TODO: update this map upon file writes.


fdbclient/VersionedMap.h (4 lines):
	- line 185: // TODO: Remove the number of invocations of operator<, and replace with something closer to memcmp.
	- line 575: // TODO look into making this per-version compaction. (We could keep track of updated nodes at each version for example)
	- line 737: k); // FIXME: Make PTreeImpl::insert do this automatically  (see also WriteMap.h FIXME)
	- line 888: // TODO: getHistory?


fdbserver/CommitProxyServer.actor.cpp (4 lines):
	- line 323: // FIXME: this is re-implementing the serialize function of MutationListRef in order to have a yield
	- line 1376: // TODO: filter if pipelined with large commit
	- line 1696: // FIXME: use the configuration to calculate a more precise minimum recovery version.
	- line 1750: // FIXME: logAntiQuorum not supported, remove it later,


fdbserver/workloads/GetRangeAndMap.actor.cpp (4 lines):
	- line 68: // TODO: When n is large, split into multiple transactions.
	- line 96: // TODO: When n is large, split into multiple transactions.
	- line 119: // TODO: When n is large, split into multiple transactions.
	- line 161: // TODO: Use toml to config


flow/xxhash.h (3 lines):
	- line 36: /* TODO: update */
	- line 2211: (defined(__s390x__) && defined(__VEC__)) && defined(__GNUC__) /* TODO: IBM XL */
	- line 2846: * FIXME: Clang's output is still _much_ faster -- On an AMD Ryzen 3600,


fdbclient/FluentDSampleIngestor.cpp (3 lines):
	- line 149: // TODO: trace error
	- line 179: } // TODO: else trace a warning
	- line 187: // TODO: error handling


recipes/java-recipes/MicroIndirect.java (3 lines):
	- line 38: // TODO This is the code for the context manager that appears at
	- line 107: // TODO These four lines are the equivalent of the initialization
	- line 126: // TODO This is the equivalent of the "with" block in the


fdbserver/DeltaTree.h (3 lines):
	- line 145: //    // TODO: Explain contract required for deltaSize to be used to predict final
	- line 547: // TODO:  Make hint-based seek() use the hint logic in this, which is better and actually improves seek times,
	- line 686: // TODO:  This is broken, it's not faster than not using a hint.  See Make thisUnfortunately in a microbenchmark


flow/network.h (3 lines):
	- line 551: // FIXME: Return a fixed point Time class
	- line 774: // TODO: make this delay configurable
	- line 799: // TODO: make this delay configurable


fdbserver/KeyValueStoreSQLite.actor.cpp (3 lines):
	- line 893: // TODO: This is really slow!
	- line 1318: // TODO:  If better performance is needed, make AsyncFileReadAheadCache work and be enabled by SQLITE_OPEN_READAHEAD
	- line 1816: cursor->clear(a.range); // TODO: at most one


fdbserver/RestoreApplier.actor.cpp (3 lines):
	- line 72: req, self, cx)); // TODO: Check how FDB uses TaskPriority for ACTORS. We may need to add
	- line 229: // TODO: Consider clearrange traffic in write traffic control
	- line 732: // TODO: Add a counter to warn when too many requests are waiting on the actor


fdbcli/fdbcli.actor.cpp (3 lines):
	- line 642: // FIXME: Factor address parsing from coordinators, include, exclude
	- line 1082: // TODO: Update the function to get rid of the Database after refactoring
	- line 2093: tokencmp(tokens[0], "getrangekeys")) { // FIXME: support byte limits, and reverse range reads


flow/ThreadHelper.actor.h (3 lines):
	- line 579: // FIXME: does not support cancellation
	- line 675: // TODO: Add SFINAE overloads for functors returning void or a non-Future type.
	- line 681: // TODO: Is this cancellation logic actually needed?


recipes/java-recipes/MicroGraph.java (3 lines):
	- line 52: // TODO These next five methods (setEdge, deleteEdge, getOutNeighbors, getInNeighbors,
	- line 95: // TODO These next two methods contain code that is referenced
	- line 139: // TODO These two lines are the code in the recipe book to handle


fdbclient/SpecialKeySpace.actor.cpp (3 lines):
	- line 202: keyAfter(result[result.size() - 1].key))); // TODO : the keyAfter will just return if key == \xff\xff
	- line 366: // TODO : workaround to write this two together to make the code compact
	- line 1901: // TODO : add limitation on set operation


fdbrpc/FlowTransport.actor.cpp (3 lines):
	- line 461: // TODO: What about when peerReference == -1?
	- line 473: // TODO: Stop monitoring and close the connection with no onDisconnect requests outstanding
	- line 1669: // throw platform_error();  // FIXME: How to recover from this situation?


fdbclient/ManagementAPI.actor.cpp (3 lines):
	- line 311: } else if (mode == "remote_three_data_hall") { // FIXME: not tested in simulation
	- line 1068: // FIXME: Actual locality!
	- line 1829: // TODO : replace using ExclusionInProgressRangeImpl in special key space


fdbclient/ManagementAPI.actor.h (3 lines):
	- line 71: NOT_COORDINATORS, // FIXME: not detected
	- line 72: DATABASE_UNREACHABLE, // FIXME: not detected
	- line 655: return ConfigurationResult::INCOMPLETE_CONFIGURATION; // FIXME: correct return type


fdbserver/RestoreApplier.actor.h (3 lines):
	- line 52: Key key; // TODO: Maybe not needed?
	- line 103: // TODO: Add SevError here
	- line 115: // TODO: Look at the last LogMessageVersion, if it set or clear, we can ignore the rest of versions.


fdbclient/BlobWorkerInterface.h (3 lines):
	- line 32: // TODO: mimic what StorageServerInterface does with sequential endpoint IDs
	- line 79: // TODO could do a reply promise stream of file mutations to bound memory requirements?
	- line 150: // TODO: could eventually add other types of metrics to report back to the manager here


fdbserver/MoveKeys.actor.cpp (3 lines):
	- line 425: // FIXME: Answer why this can happen?
	- line 618: // FIXME: Is this the right behavior?  dataMovementComplete will never be sent!
	- line 1010: // FIXME: don't fetch tag localities, all tags, and history tags if tss. Just fetch pair's tag


fdbclient/SystemData.cpp (3 lines):
	- line 560: // TODO use flatbuffers depending on version
	- line 653: // FIXME: make sure what's persisted here is not affected by innocent changes elsewhere
	- line 682: // FIXME: make sure what's persisted here is not affected by innocent changes elsewhere


fdbclient/SimpleConfigTransaction.actor.cpp (3 lines):
	- line 118: // TODO: Improve this:
	- line 261: // TODO: Support using this option to determine atomicity
	- line 269: // TODO: Implement someday


fdbserver/ClusterRecovery.actor.cpp (3 lines):
	- line 1069: // FIXME: we only need log routers for the same locality as the master
	- line 1260: oldLogSystem->getEnd()); //< FIXME: (1) the log adapter should do this automatically after recovery; (2) if we
	- line 1848: // TODO: ServerKnob should be removed ones all tooling scripts and usage is identified and updated accordingly


flow/Tracing.actor.cpp (3 lines):
	- line 205: // TODO: Add support for longer strings if necessary.
	- line 231: // TODO: Add support for longer vectors if necessary.
	- line 246: // TODO: Add support for longer maps if necessary.


flow/Arena.h (3 lines):
	- line 401: // FIXME: something like BinaryReader(ar) >> arena >> *(T*)this; to guarantee standalone arena???
	- line 819: // TODO: There should be an easier way to identify the difference between flow_ref and non-flow_ref types.
	- line 1428: // FIXME: range checking for length, here and in other serialize code


fdbserver/sqlite/btree.c (3 lines):
	- line 4713: /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries
	- line 5158: ** TODO: collapse this trunk into a neighbor if searchList?
	- line 8189: // FIXME: This check fails for us, probably it is a (performance) bug!


recipes/java-recipes/MicroMulti.java (2 lines):
	- line 46: // TODO These two methods (addHelp and getLong) are used by the methods
	- line 69: // TODO These five methods are definitely in the recipe book


fdbserver/LocalConfiguration.actor.cpp (2 lines):
	- line 235: // FIXME: Reinitialize in order to update dependent knobs?
	- line 270: // TODO: Concurrency control?


fdbrpc/FlowTests.actor.cpp (2 lines):
	- line 250: // Delegate everything else.  TODO: Make a base class NetworkWrapper for delegating everything in INetwork
	- line 420: // TODO: This needs to fiddle with g_currentDeliveryPeerAddress


fdbserver/RestoreWorkerInterface.actor.h (2 lines):
	- line 61: // TODO: If it turns out this struct only has appliers in the final version, we will rename it to a more specific name,
	- line 378: // TODO: Compare all fields for loadingParam


fdbclient/StorageServerInterface.h (2 lines):
	- line 309: // TODO: Get rid of this by constexpr or other template magic in getRange
	- line 479: // FIXME: currently, neither of bytesPerKSecond or iosPerKSecond are actually used in DataDistribution calculations.


fdbclient/WriteMap.h (2 lines):
	- line 262: e.key); // FIXME: Make PTreeImpl::insert do this automatically (see also VersionedMap.h FIXME)
	- line 414: removals[i]); // FIXME: Make PTreeImpl::insert do this automatically (see also VersionedMap.h FIXME)


fdbcli/StatusCommand.actor.cpp (2 lines):
	- line 416: // FIXME: Should we suppress this if there are cluster messages implying that the database has no
	- line 889: // FIXME:  Above comment is not what this code block does, it actually just looks for a specific message


fdbserver/ApplyMetadataMutation.cpp (2 lines):
	- line 293: .castTo<StringRef>()) { // FIXME: Make this check more specific, here or by reading
	- line 925: // TODO Note that, we are currently not handling the case when cached key-ranges move out


fdbserver/IDiskQueue.h (2 lines):
	- line 41: } // FIXME: Return a 'HumanReadableDescription' instead of std::string, make TraceEvent::detail accept that (for
	- line 103: // FIXME: One should be able to use SFINAE to choose between serialize and serialize_unversioned.


fdbbackup/backup.actor.cpp (2 lines):
	- line 2465: // TODO: Support addPrefix and removePrefix
	- line 4215: // TODO: We have not implemented the code commented out in this case


fdbserver/workloads/MachineAttrition.actor.cpp (2 lines):
	- line 288: int killType = deterministicRandom()->randomInt(0, 3); // FIXME: enable disk stalls
	- line 372: // FIXME: enable disk stalls


fdbclient/ThreadSafeTransaction.cpp (2 lines):
	- line 306: // FIXME: prevent from calling this from another main thread!
	- line 318: // FIXME: can this safely avoid another main thread jump?


fdbcli/BlobRangeCommand.actor.cpp (2 lines):
	- line 43: // FIXME: check that the set range is currently inactive, and that a revoked range is currently its own
	- line 71: // TODO is this something we want?


fdbserver/workloads/ConfigIncrement.actor.cpp (2 lines):
	- line 122: ASSERT(g_network->isSimulated()); // TODO: Enforce elsewhere
	- line 148: // TODO: The timeout is a hack to get the test to pass before rollforward and


fdbserver/StorageMetrics.actor.h (2 lines):
	- line 127: // FIXME: both versions of erase are broken, because they do not remove items in the queue with will subtract a
	- line 202: bandwidthSample; // FIXME: iops and bandwidth calculations are not effectively tested, since they aren't


bindings/java/src/junit/com/apple/foundationdb/FakeFDBTransaction.java (2 lines):
	- line 92: // TODO: map is not supported in FakeFDBTransaction yet.
	- line 97: // TODO this is probably not correct for all KeySelector instances--we'll want to match with real behavior


fdbclient/StorageServerInterface.cpp (2 lines):
	- line 21: // TODO this should really be renamed "TSSComparison.cpp"
	- line 205: // TODO this is all duplicated from above, simplify?


fdbrpc/AsyncFileKAIO.actor.h (2 lines):
	- line 637: // TODO:  Don't do this hacky investigation-specific thing
	- line 644: // TODO: don't hardcode this path


fdbserver/OldTLogServer_4_6.actor.cpp (2 lines):
	- line 1422: // FIXME: update tlogMetrics to include new information, or possibly only have one copy for the shared instance
	- line 1455: // FIXME: metadata in queue?


fdbmonitor/fdbmonitor.cpp (2 lines):
	- line 100: kevent(list, &ev, 1, nullptr, 0, nullptr); // FIXME: check?
	- line 110: kevent(list, &ev, 1, nullptr, 0, nullptr); // FIXME: check?


fdbclient/SnapshotCache.h (2 lines):
	- line 239: } while (endKey() == originalEnd); // TODO: pointer only comparison; maintain equality of pointers to keys
	- line 266: it = parent->entries.lastLessOrEqual(Entry(key, key, VectorRef<KeyValueRef>())); // TODO: finger query?


recipes/java-recipes/MicroRange.java (2 lines):
	- line 48: // TODO This loop in recipe book.
	- line 63: // TODO This method in recipe book.


fdbserver/workloads/ClientTransactionProfileCorrectness.actor.cpp (2 lines):
	- line 308: // FIXME: Better way to ensure that all client profile data has been flushed to the database
	- line 351: // FIXME: Find a way to check that contentsSize is not greater than a certain limit.


flow/TDMetric.actor.h (2 lines):
	- line 1035: // TODO:  A Standalone key type isn't ideal because on lookups a ref will be made Standalone just for the search
	- line 1079: // FIXME:  This will break for DynamicEventMetric instances that are reused, such as use cases outside


layers/compressedColumn/compressedColumn.py (2 lines):
	- line 254: # FIXME: Unpack the overlapping packed block and try again
	- line 311: # FIXME: Should we read unpacked after getting the result of the packed data?  If we do, then we can more accurately limit the number


fdbrpc/dsltest.actor.cpp (2 lines):
	- line 247: //delete[] x;    // TODO: Free large pages
	- line 585: // FIXME: Doesn't work as written with auto-reset


fdbserver/LogSystem.h (2 lines):
	- line 152: // version().subsequence will be zero)  < FIXME: Can we lose this property?
	- line 453: // FIXME: collectTags is needed to support upgrades from 5.X to 6.0. Remove this code when we no longer support


fdbserver/ClusterController.actor.cpp (2 lines):
	- line 991: // TODO why construct a new one and not just copy the old one and change proxies + id?
	- line 1276: // FIXME: replace or augment this with logging on the proxy which tracks


fdbserver/ConfigFollowerInterface.h (2 lines):
	- line 70: // TODO: Share arena
	- line 107: // TODO: Share arena


fdbclient/BackupContainer.h (2 lines):
	- line 40: // TODO: Move the log file and range file format encoding/decoding stuff to this file and behind interfaces.
	- line 306: // TODO: change the following back to `private` once blob obj access is refactored


fdbserver/MutationTracking.h (2 lines):
	- line 35: // TODO: Create a TraceEventGroup that forwards all calls to each element of a std::vector<TraceEvent>,
	- line 44: // TODO: Version Tracking.  If the bug is in handling a version rather than a key, then it'd be good to be able to log


fdbserver/Coordination.actor.cpp (2 lines):
	- line 364: // TODO: use notify to only send a heartbeat once per interval
	- line 574: // FIXME: Get worker ID here


fdbclient/HTTP.actor.cpp (2 lines):
	- line 99: // TODO:  resize is zero-initializing the space we're about to overwrite, so do something else, which probably
	- line 313: // TODO:  pSent is very hackish, do something better.


fdbclient/Tuple.cpp (2 lines):
	- line 23: // TODO: Many functions copied from bindings/flow/Tuple.cpp. Merge at some point.
	- line 303: // TODO: Combine with bindings/flow/Tuple.*. This code is copied from there.


fdbserver/LogSystemPeekCursor.actor.cpp (2 lines):
	- line 1028: // FIXME: if best set is exhausted, do not peek remote servers
	- line 1061: // FIXME: this will peeking way too many cursors when satellites exist, and does not need to peek


bindings/c/fdb_c.cpp (2 lines):
	- line 605: // TODO: Support FDB_API_ADDED in generate_asm.py and then this can be replaced with fdb_api_ptr_unimpl.
	- line 799: // FIXME: better way to convert?


fdbclient/MultiVersionTransaction.actor.cpp (2 lines):
	- line 275: // FIXME: better way to convert here?
	- line 1635: if (!client->failed || runOnFailedClients) { // TODO: Should we ignore some failures?


fdbclient/BlobGranuleCommon.h (2 lines):
	- line 73: // TODO could filter out delta files that don't intersect the key range being requested?
	- line 74: // TODO since client request passes version, we don't need to include the version of each mutation in the response if we


fdbclient/SystemData.h (2 lines):
	- line 28: #include "fdbclient/BlobWorkerInterface.h" // TODO move the functions that depend on this out of here and into BlobWorkerInterface.h to remove this depdendency
	- line 546: // FIXME: flip order of {filetype, version}


flow/Trace.cpp (2 lines):
	- line 392: // FIXME: What if we are using way too much memory for buffer?
	- line 572: writer->addref(); // FIXME: We are not shutting down the writer thread at all, because the ThreadPool


fdbserver/QuietDatabase.actor.cpp (2 lines):
	- line 504: // TODO: Remove the constraint SERVER_KNOBS->DESIRED_TEAMS_PER_SERVER == 3 to ensure that
	- line 602: // FIXME: the primary and remote can both be considered dead because excludes are not handled properly by the


fdbserver/workloads/ConfigureDatabase.actor.cpp (2 lines):
	- line 141: // FIXME: implement
	- line 174: // FIXME: implement


fdbclient/BackupContainerAzureBlobStore.actor.cpp (2 lines):
	- line 317: // TODO: More descriptive error?
	- line 397: // TODO: Implement this


fdbclient/MutationList.h (2 lines):
	- line 141: // FIXME: More efficient?  Eliminate?
	- line 158: // FIXME: this is re-implemented on the commit proxy to include a yield, any changes to this function should also


fdbserver/workloads/SpecialKeySpaceCorrectness.actor.cpp (2 lines):
	- line 279: // TODO : fix knobs for row_unlimited
	- line 519: // TODO test that fails if we don't wait on tx->pendingReads()


flow/sse2neon.h (2 lines):
	- line 717: float32x2_t a02 = vset_lane_f32(a0, a22, 1); /* TODO: use vzip ?*/
	- line 2070: /* FIXME: issue with large values because of result saturation */


fdbclient/BackupContainer.actor.cpp (2 lines):
	- line 24: // FIXME: Trim this down
	- line 346: // TODO: Enable this when Azure backups are ready


fdbserver/fdbserver.actor.cpp (2 lines):
	- line 207: // FIXME: this really belongs in a header somewhere since it is actually used.
	- line 1670: // TODO: Remove later, this is just to force the statics to be initialized


recipes/java-recipes/MicroDoc.java (2 lines):
	- line 32: // TODO Everything in this class up until the few methods at the end
	- line 213: //TODO Everything in this class before here is in the doc.


fdbserver/LogRouter.actor.cpp (2 lines):
	- line 167: // TODO: Add minPopped locality and minPoppedId, similar as tLog Metrics
	- line 334: when(wait(dbInfoChange)) { // FIXME: does this actually happen?


flow/Histogram.cpp (2 lines):
	- line 24: // TODO: remove dependency on fdbrpc.
	- line 36: // TODO: create a execution context abstraction that allows independent flow instances within a process.


fdbclient/ServerKnobs.h (2 lines):
	- line 666: // TODO: After 6.3, review FR knobs, remove unneeded ones and change default value
	- line 752: // FIXME: configure url with database configuration instead of knob eventually


recipes/java-recipes/MicroBlob.java (2 lines):
	- line 49: // TODO This method is in the recipe book.
	- line 70: // TODO This method is in the recipe book.


fdbclient/ActorLineageProfiler.cpp (1 line):
	- line 223: // TODO: Should only call ingest when deleting from memory


fdbclient/SpecialKeySpace.actor.h (1 line):
	- line 45: // TODO : give this function a more descriptive name


fdbserver/ResolverInterface.h (1 line):
	- line 102: Version version; // FIXME: ?


fdbserver/RestoreRoleCommon.actor.cpp (1 line):
	- line 148: // TODO: Set FASTRESTORE_WAIT_FOR_MEMORY_LATENCY to a large value. It should be able to avoided


cmake/ConfigureCompiler.cmake (1 line):
	- line 100: # TODO: This doesn't seem to be good style, but I couldn't find a better way so far


fdbserver/workloads/KillRegion.actor.cpp (1 line):
	- line 87: // FIXME: killDataCenter breaks simulation if forceKill=false, since some processes can survive and


recipes/java-recipes/MicroQueue.java (1 line):
	- line 42: // TODO The next four elements are in the recipe book:


fdbclient/StatusClient.actor.cpp (1 line):
	- line 542: // TODO: this is a temporary fix, getting the number of available coordinators should move to


fdbserver/MetricLogger.actor.cpp (1 line):
	- line 71: // TODO:  Support more complex patterns?


bindings/c/foundationdb/fdb_c.h (1 line):
	- line 199: /* TODO: add other return types as we need them */


fdbrpc/Locality.cpp (1 line):
	- line 303: // FIXME: add this back in when load balancing works with local requests


fdbserver/RestoreController.actor.h (1 line):
	- line 322: // TODO: Check why this may happen?!


flow/TLSConfig.actor.h (1 line):
	- line 187: // TODO: make an easy to use Future<bool> fileExists, and port lots of code over to it.


fdbserver/workloads/SnapTest.actor.cpp (1 line):
	- line 81: // FIXME: currently validation works on numSnap = 1


fdbserver/art_impl.h (1 line):
	- line 1115: min_of_n == nullptr ? minimum(n) : min_of_n; // minimum(n); //FIXME: reuse from before if already taken


fdbserver/RestoreWorkerInterface.actor.cpp (1 line):
	- line 90: // TODO: Register restore performance data to restoreStatus key


fdbserver/workloads/RandomMoveKeys.actor.cpp (1 line):
	- line 193: if (self->configuration.usableRegions > 1) { // FIXME: add support for generating random teams across DCs


flow/Deque.h (1 line):
	- line 43: // TODO: iterator construction, other constructors


fdbclient/ClientKnobs.h (1 line):
	- line 34: int TOO_MANY; // FIXME: this should really be split up so we can control these more specifically


layers/taskbucket/__init__.py (1 line):
	- line 31: # TODO: Make this fdb.tuple.subspace() or similar?


fdbserver/workloads/FastTriggeredWatches.actor.cpp (1 line):
	- line 143: // TODO: This assertion can cause flaky behaviour since sometimes a watch can take longer to fire


bindings/flow/fdb_flow.actor.cpp (1 line):
	- line 385: // FIXME: iteration


fdbserver/RestoreCommon.actor.h (1 line):
	- line 46: // TODO: Merge this RestoreConfig with the original RestoreConfig in FileBackupAgent.actor.cpp


fdbclient/IKnobCollection.cpp (1 line):
	- line 55: // TODO: Ideally it should not be necessary to create a template object to parse knobs


fdbclient/JsonBuilder.h (1 line):
	- line 31: // TODO: Remove the need for this by changing usages to steal this's content


flow/ThreadPrimitives.h (1 line):
	- line 48: // TODO: We should make this dependent on the CPU. Maybe cmake


fdbserver/RestoreWorker.actor.cpp (1 line):
	- line 217: // TODO: Needs to keep this monitor's future. May use actorCollection


recipes/java-recipes/MicroVector.java (1 line):
	- line 38: // TODO These two methods--the get and set methods--are in the recipes.


bindings/flow/tester/Tester.actor.cpp (1 line):
	- line 1820: populateAtomicOpMap(); // FIXME: NOOOOOO!


fdbclient/BackupAgentBase.actor.cpp (1 line):
	- line 62: // TODO:  Use std::get_time implementation for all platforms once supported


fdbrpc/AsyncFileEncrypted.actor.cpp (1 line):
	- line 133: // TODO: Could optimize this


recipes/java-recipes/MicroIndexes.java (1 line):
	- line 42: // TODO These three methods (setUser, getUser, and getUserIDsInRegion)


fdbserver/GrvProxyServer.actor.cpp (1 line):
	- line 437: // TODO: check whether this is reasonable to do in the fast path


recipes/java-recipes/MicroPriority.java (1 line):
	- line 43: // TODO The next six methods are all in the recipe book:


fdbserver/IKeyValueStore.h (1 line):
	- line 162: UNREACHABLE(); // FIXME: is this right?


fdbserver/WorkerInterface.actor.h (1 line):
	- line 653: // FIXME: Rename to InitializeMasterRequest, etc


fdbserver/FDBExecHelper.actor.h (1 line):
	- line 45: // FIXME: move this function to a common location


fdbclient/BackupAgent.actor.h (1 line):
	- line 52: FDB_DECLARE_BOOLEAN_PARAM(DstOnly); // TODO: More descriptive name?


fdbclient/RYWIterator.cpp (1 line):
	- line 369: // TODO: Is there a more efficient way to deal with invalidation?


fdbrpc/libeio/eio.c (1 line):
	- line 122: /* TODO: look at how perl does stat (non-sloppy), unlink (ro-files), utime, link */


fdbrpc/AsyncFileReadAhead.actor.h (1 line):
	- line 70: return 0; // TODO:  Should this throw since the input isn't really valid?


flow/FastAlloc.cpp (1 line):
	- line 527: // FIXME: We should be able to allocate larger magazine sizes here if we


fdbrpc/LoadBalance.actor.h (1 line):
	- line 273: // FIXME: optimize to avoid creating new netNotifiedQueue for each message


fdbserver/workloads/Storefront.actor.cpp (1 line):
	- line 289: // FIXME: match order table with inventory table


fdbserver/Resolver.actor.cpp (1 line):
	- line 154: wait(delay(0, TaskPriority::Low) || delay(SERVER_KNOBS->COMMIT_SLEEP_TIME)); // FIXME: Is this still right?


fdbrpc/fdbrpc.h (1 line):
	- line 734: // FIXME: defer sending the message until we know the connection is established


fdbrpc/AsyncFileCached.actor.h (1 line):
	- line 558: writing.send(Void()); // FIXME: This could happen before the wait if AsyncFileKAIO dealt properly with


fdbcli/ConfigureCommand.actor.cpp (1 line):
	- line 148: // TODO: disable completion


fdbrpc/ReplicationUtils.cpp (1 line):
	- line 229: //    - TODO: More specializations for common policies


fdbserver/workloads/RestoreBackup.actor.cpp (1 line):
	- line 96: // TODO: Batch to avoid large clear ranges?


fdbserver/KeyValueStoreMemory.actor.cpp (1 line):
	- line 544: .arena()); // FIXME: Not sure what this line is for, is it necessary?


flow/network.cpp (1 line):
	- line 117: // TODO: Use IPAddress::parse


fdbclient/BackupContainerFileSystem.h (1 line):
	- line 83: // TODO: refactor this to separate out the "deal with blob store" stuff from the backup business logic


fdbserver/sqlite/btree.h (1 line):
	- line 22: /* TODO: This definition is just included so other modules compile. It


fdbrpc/ReplicationPolicy.cpp (1 line):
	- line 182: // FIXME: Simplify this function, such as removing unnecessary printf


bindings/flow/Subspace.cpp (1 line):
	- line 75: // FIXME: test that this uses the keyRange arena and doesn't create another one


fdbserver/workloads/DataDistributionMetrics.actor.cpp (1 line):
	- line 139: // TODO : find why this not work


fdbserver/workloads/Performance.actor.cpp (1 line):
	- line 106: // FIXME: does not use testers which are recruited on workers


fdbclient/Subspace.cpp (1 line):
	- line 74: // FIXME: test that this uses the keyRange arena and doesn't create another one


fdbserver/IPager.h (1 line):
	- line 294: // TODO: Document further.


flow/flow.h (1 line):
	- line 269: // FIXME: this code will not work for caching a direct serialization from ObjectWriter, because it adds an ErrorOr,


fdbrpc/libcoroutine/Coro.c (1 line):
	- line 175: // FIXME: The commented code below could be adapted to find the actual stack size using pthreads


fdbserver/CoordinationInterface.h (1 line):
	- line 36: //     returns (Optional(),0,0)   //< FIXME: The returned rgen is not zero, but >= gen2!  (Specification bug)


fdbserver/ApplyMetadataMutation.h (1 line):
	- line 35: // FIXME: This is conservative - not everything in system keyspace is necessarily processed by


recipes/java-recipes/MicroTable.java (1 line):
	- line 45: // TODO The recipe book definitely includes the following things:


fdbclient/GlobalConfig.actor.h (1 line):
	- line 85: // TODO: Change AsyncTrigger to a Reference


flow/actorcompiler/ActorCompiler.cs (1 line):
	- line 673: // TODO: Could we use EmitNativeLoop() here?


recipes/java-recipes/MicroSpatial.java (1 line):
	- line 40: // TODO These three methods, xyToZ, zToXy, and setLocation, are allin the recipe book.


fdbclient/DatabaseBackupAgent.actor.cpp (1 line):
	- line 670: BinaryWriter::toValue(1, Unversioned()); // FIXME: remove in 6.X, only needed for 5.2 backward compatibility


flow/Error.h (1 line):
	- line 135: // TODO: magic so this works even if const-ness doesn not match.


fdbserver/workloads/Mako.actor.cpp (1 line):
	- line 391: // TODO: Do I need to read data to warm the cache of the keySystem like ReadWrite.actor.cpp (line 465)?