Memory-bound function
This article includes a improve this article by introducing more precise citations. (September 2020) ) |
Memory bound refers to a situation in which the time to complete a given
Memory and computation boundaries can sometimes be traded against each other, e.g. by saving and reusing preliminary results or using lookup tables.
Memory-bound functions and memory functions
Memory-bound
Memory functions use a
Fibonacci (n)
{
for i = 0 to n-1
results[i] = -1 // -1 means undefined
return Fibonacci_Results (results, n);
}
Fibonacci_Results (results, n)
{
if (results[n] != -1) // If it has been solved before,
return results[n] // look it up.
if (n == 0)
val = 0
else if (n == 1)
val = 1
else
val = Fibonacci_Results(results, n-2 ) + Fibonacci_Results(results, n-1)
results[n] = val // Save this result for re-use.
return val
}
Compare the above to an algorithm that uses only recursion, and runs in
Recursive_Fibonacci (n)
{
if (n == 0)
return 0
if (n == 1)
return 1
return Recursive_Fibonacci (n-1) + Recursive_Fibonacci (n-2)
}
While the recursive-only algorithm is simpler and more elegant than the algorithm that uses recursion and memoization, the latter has a significantly lower time complexity than the former.
The term "memory-bound function" has surfaced only recently and is used principally to describe a function that uses XOR and consists of a series of computations in which each computation depends on the previous computation. Whereas memory functions have long been an important actor in improving time complexity, memory-bound functions have seen far fewer applications. Recently[when?], however, scientists have proposed a method using memory-bound functions as a means to discourage spammers from abusing resources, which could be a major breakthrough in that area.
Using memory-bound functions to prevent spam
Memory-bound functions might be useful in a proof-of-work system that could deter spam, which has become a problem of epidemic proportions on the Internet.
In 1992, IBM research scientists
Dwork and Naor proposed that spamming might be reduced by injecting an additional cost in the form of an expensive
The basic scheme that protects against abuses is as follows:
Let S be sender, R be recipient, and M be an e-mail. If R has agreed beforehand to receive e-mail from S, then M is transmitted in the usual way. Otherwise, S computes some function G(M) and sends (M, G(M)) to R. R checks if what it receives from S is of the form (M, G(M)). If yes, R accepts M. Otherwise, R rejects M. The figure on the right depicts cases in which there were no prior agreements.
The function G() is selected such that the verification by R is relatively fast (taking a millisecond) and such that the computation by S is somewhat slow (involving at least several seconds). Therefore, S will be discouraged from sending M to multiple recipients with no prior agreements: the cost in terms of both time and computing resources of computing G() repeatedly will become very prohibitive for a spammer who intends to send many millions of e-mails.
The major problem of using the above scheme is that fast CPUs compute much faster than slow CPUs. Further, higher-end computer systems also have sophisticated pipelines and other advantageous features that facilitate computations. As a result, a spammer with a state-of-the-art system will hardly be affected by such deterrence while a typical user with a mediocre system will be adversely affected. If a computation takes a few seconds on a new
The new egalitarian approach is to rely on memory-bound functions. As stated before, a memory-bound function is a function whose computation time is dominated by the time spent accessing memory. A memory-bound function accesses locations in a large region of memory in an unpredictable way, in such a way that using caches are not effective. In recent years, the speed of CPU has grown drastically, but there has been comparatively small progress in developing faster main memory. Since the ratios of memory latencies of machines built in the last five years is typically no greater than two, and almost always less than four, the memory-bound function will be egalitarian to most systems for the foreseeable future.
See also
- Computer architecture
- CPU-bound
- Dynamic programming
- I/O-bound
- Memoization
- Memory-hard function
- Optimal substructure
- Proof of work
- Recursion
- Memory bottleneck
References
- Abadi, M., Burrows, M., Manasse, M., & Wobber, T. (2005, May). Moderately Hard, Memory-bound Functions, ACM Transactions on Internet Technology.
- Dwork, C., Goldberg, A., & Naor, M. (2003). On Memory-Bound Functions for Fighting Spam, Advances in Cryptology.
- Hellman, M. E. (1980). A Cryptanalytic Time-Memory Trade Off, IEEE Transactionson Information Theory.