memcached-rs 0.1.3

A MemCached Library in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

#![feature(phase)]
#[phase(plugin, link)]
extern crate log;
extern crate time;
extern crate memcached;

use std::rand::random;
use std::collections::TreeMap;

use memcached::client::Client;
use memcached::proto::{Operation, MultiOperation, NoReplyOperation, Binary};

fn generate(len: uint) -> Vec<u8> {
    let mut key = Vec::with_capacity(len);
    for _ in (0..len) {
        key.push(random::<u8>());
    }

    key
}

fn main() {
    let mut client = Client::connect([
                                ("127.0.0.1:11211", Binary, 1),
                                ("127.0.0.1:11212", Binary, 3),
                            ]);

    const TOTAL_KEY: uint = 10240;
    const KEY_LEN: uint = 20;
    const VAL_LEN: uint = 4 * 1024;

    let mut kv = TreeMap::new();
    for _ in (0..TOTAL_KEY) {
        kv.insert(generate(KEY_LEN), (generate(VAL_LEN), 0xcafebabe, 20));
    }
    info!("Test cases is generated. Total {}, Key length {}bytes, Value length {}bytes", TOTAL_KEY, KEY_LEN, VAL_LEN);

    info!("Trying set with reply...");

    let beg = time::now().to_timespec();
    for (k, (val, flags, exp)) in kv.clone().into_iter() {
        client.set(k.as_slice(), val.as_slice(), flags, exp).unwrap();
    }
    let end = time::now().to_timespec();

    info!("set {}", end - beg);

    client.flush_all().unwrap();

    info!("Trying set_multi...");

    let beg = time::now();
    client.set_multi(kv.clone()).unwrap();
    let end = time::now();

    info!("set_multi {}", end.to_timespec() - beg.to_timespec());

    client.flush_all().unwrap();

    info!("Trying set_noreply...");

    let beg = time::now();
    for (k, (val, flags, exp)) in kv.clone().into_iter() {
        client.set_noreply(k.as_slice(), val.as_slice(), flags, exp).unwrap();
    }
    let end = time::now();

    info!("set_noreply {}", end.to_timespec() - beg.to_timespec());

    info!("Trying get...");
    let beg = time::now();
    for (k, (expected, _, _)) in kv.clone().into_iter() {
        let (value, _) = client.get(k.as_slice()).unwrap();
        // assert_eq!(value, expected);
    }
    let end = time::now();
    info!("get {}", end.to_timespec() - beg.to_timespec());

    info!("Trying multi_get...");
    let keys: Vec<Vec<u8>> = kv.keys().map(|k| k.clone()).collect();
    let beg = time::now();
    let values = client.get_multi(keys).unwrap();
    for (k, (expected, flags, _)) in kv.clone().into_iter() {
        let get_result = values.find(&k);
        let expect = &(expected, flags);
        // assert_eq!(get_result, Some(expect));
    }
    let end = time::now();
    info!("multi_get {}", end.to_timespec() - beg.to_timespec());

    info!("Trying delete_multi...");

    let keys: Vec<Vec<u8>> = kv.keys().map(|k| k.clone()).collect();
    client.delete_multi(keys).unwrap();

    info!("Succeed");
}