blockchainevmsolidity
In solidity contracts, I can understand that based on variable usage and expensiveness, I can determine that which one should use (memory, storage or stack). But I faced some situations where only memory can be used and like that.
So my question is:
Where only memory can be used?
Where only storage can be used?
Where only stack can be used?
I couldn't find any documentation that states specific area should be used in any specific situation.
Thanks
In storage, variables are packed tightly, so your struct will fit in one word. See this page of the docs: http://solidity.readthedocs.io/en/latest/miscellaneous.html
For parameters, packing's less important since it's ephemeral data. Function arguments are always in memory: https://solidity.readthedocs.io/en/latest/frequently-asked-questions.html#what-is-the-memory-keyword-what-does-it-do
Another question though is the format of the transaction that goes over the wire. I'm having trouble finding the documentation for the format, but I did find a page saying that arguments are padded to 32 bytes in the ABI: https://github.com/ethereum/wiki/wiki/Solidity-Features
In any case it's definitely not a major cost difference. Looking at gas prices in the yellow paper, storing one word is 20,000 gas. Each nonzero byte of transaction data is just 68 gas. If each parameter is padded to 256 bits, then we'll have a bunch of zero bytes, and those only cost 4 gas. (Since zeros are cheaper I'm tempted to think these are packed, but I don't know for sure.)
They will be in storage as memory should be cleared after each transaction. So if a mapping was anything but storage it would not persist. Anything defined within the scope of a contract will be stored in that contract's storage.
What is the memory keyword? What does it do? The Ethereum Virtual Machine has three areas where it can store items.
The first is “storage”, where all the contract state variables reside. Every contract has its own storage and it is persistent between function calls and quite expensive to use.
The second is “memory”, this is used to hold temporary values. It is erased between (external) function calls and is cheaper to use.
The third one is the stack, which is used to hold small local variables. It is almost free to use, but can only hold a limited amount of values.
Here's the proof of work Ethereum Blockchain Mechanism
Also see Where are the variables of a smart contract stored?
Best Answer
Storage
Let's consider storage first. Storage is extremely expensive. It costs 20000 gas to set a storage location from zero to a value, and 5000 gas to change its value. (You do get some gas back for resetting a location to 0.) The reason is that a contract's storage values are stored on the blockchain forever which has a real-world cost. It's also 200 gas to read a word, compared with 3 for memory.
So for storage, use it only when you really must.
When must you use storage? For values that have to be persisted between different contract calls. For example the balances of accounts for an ERC20 token. Storage updates are state updates of your contract and are not really for temporary data. Storage of one contract can also be read by another contract, or by querying the blockchain without running the contract.
You can think of it like hard disk/SSD, if you like. Storage retains its value when the computer's not running.
Memory
Memory is relatively much cheaper than storage. It costs 3 gas to read or write a word, plus some gas if you are expanding memory. For a few KB it's very cheap indeed, but the cost goes up quadratically the more you use: a megabyte of memory will cost a couple of million gas.
However, the memory is only accessible during contract execution; once execution is finished, its contents are discarded.
When should you use memory? Pretty much for everything non-permanent. It's the general workhorse.
You can think of it like a computer's RAM. It vanishes when the computer is not running.
Stack
The costs of storing data on the stack are similar to those for memory. Sometimes there will be less overhead from having to push memory addresses to the stack; sometimes there will be more overhead as the compiler has to shuffle things around on the stack. The stack has a maximum capacity of 1024 items, but only the top 16 are easily accessible. If you run out of stack then contract execution will fail. The compiler generally uses it for intermediate values in computations and other scratch quantities.
On the whole, I'd leave the stack to the compiler to work out.
The stack also does not persist after contract termination.
All the info above is buried in the Yellow Paper - I've read it so you don't have to :-)