* Enable  Issue Auto-close

* Update URL and README.md

- Making Item public makes the onEvict and onReject function calls more readable.
- Adding onReject allows us to tightly track every Set that happens, so we can avoid memory leaks in manually allocated memory.

If cache is too small, keys can enter and leave very quickly. This results in poor cache usage. Adding a life expectancy histogram to track a sample of keys from admission into cache to eviction. If we see too many keys getting evicted quickly, (along with miss ratio) that's a clear signal that cache size is too small. This would help a user tweak cache size better.

Add a new OnExit handler, which is called every time an accepted value by Ristretto is let go. This is useful for manual memory management.

Move Calloc from Badger over to Ristretto in z package, so Ristretto, Badger and Dgraph can all use it.

Cache operations are handled asynchronously. Calling the Wait method will add an item to the
process queue and block until that item is processed. Useful to ensure all the previous items
have been processed before proceeding.

Introduce z.Calloc, z.CallocNoRef and z.Free, to use jemalloc for memory allocation and deallocation to reduce pressure from Go GC.

Introduce y.Buffer which can use manual memory management. y.Buffer also has a way to encode lots of smaller buffers into this big buffer and access them via offsets. This can be used for sorting them, as we do in bulk loader.

Changes:
* add a hack to disable free
* Add a memtest
* Add modes to showcase the memory leak problem.
* Add a C program to verify that memory fragmentation is not an issue
* Bind port to host, so I can access it from my laptop
* Use jemalloc for Calloc and Free.
* Add a way to print jemalloc stats.
* Switch jemalloc prefix to je_
* Use a new jemalloc build tag
* Move Buffer class over to z
* Add a new func called CallocNoRef to deal with object allocations.
* Don't do memory tracking in Go mode.
* Move memtest to contrib
* Add godocs because Daniel made me write them

* Delete .travis.yml

* add test.sh file

Internally it uses Calloc, so the memory could be allocated via either Go or jemalloc, depending upon what's enabled. The allocated memory is then safe to be unsafe type casted to Go structs.

JE Malloc is used to manually allocate memory. This PR adds a `ReadMemStats` 
function (similar to runtime.ReadMemStats) that can be used to fetch JE Malloc statistics at runtime.

This PR  supports fetching `Allocated, Active, Retained, and Resident` memory information.

Fixes - DGRAPH-2382

Buffers can now be mmapped as well as Calloc'd. This PR also copies over all the mmap files from Badger to allow mmap support in various platforms.

This PR also introduces Merge Sort to do sorting of the buffer using an extra temporary space costing half of the space as the original buffer, currently allocated on Calloc. We can't use quick sort. Each entry is variable length, so we can't just swap them in the buffer. Merge Sort allows us to iterate over them linearly, hence is a better fit.

Allow a buffer allocated via Calloc to switch to Mmap after it grows beyond a certain size.

- Use an int64 instead of a time.Time struct to represent the time.
- By default, include the cost of the storeItem in the cost calculation.

Related to DGRAPH-1378

MaxInt64 is 9.2 Exabyte and the test fails with cannot allocate memory on my computer.
This PR also fixes the build (it is failing on master).

This PR adds a TotalSize function which returns the total size of the bloom filter.

The process crashes when other public methods are called after `Close()`. That must be handled gracefully.

```
panic: send on closed channel

goroutine 24430 [running]:
code.uber.internal/infra/statsdex/vendor/github.com/dgraph-io/ristretto.(*defaultPolicy).Push(0xc000676060, 0xc1417ed200, 0x40, 0x40, 0x3)
	code.uber.internal/infra/statsdex/vendor/github.com/dgraph-io/ristretto/policy.go:112 +0x64
```

…ose.

Add an IncementOffset API for z.buffers which is a thread-safe API for 
incrementing the buffer offset.

This PR adds a custom mmaped B+ tree. This data structure creates a mapping from uint64 to uint64.

Structure of node:
Each node in the node is of size pageSize. Two kinds of nodes. Leaf nodes and internal nodes.
Leaf nodes only contain the data. Internal nodes would contain the key and the offset to the child node.
Internal node would have first entry as:
<0 offset to child>, <1000 offset>, <5000 offset>, and so on...
Leaf nodes would just have: <key, value>, <key, value>, and so on...
Last 16 bytes of the node are off limits.
| pageID (8 bytes) | metaBits (1 byte) | 3 free bytes | numKeys (4 bytes) |

…ix (#208)