chiavdf 1.1.13

Bindings to the chiavdf C++ library.
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

#ifdef GENERATE_ASM_TRACKING_DATA
    const bool generate_asm_tracking_data=true;
#else
    const bool generate_asm_tracking_data=false;
#endif

namespace asm_code {


string track_asm(string comment, string jump_to = "") {
    if (!generate_asm_tracking_data) {
        return jump_to;
    }

    mark_vdf_test();

    static map<string, int> id_map;
    static int next_id=1;

    int& id=id_map[comment];
    if (id==0) {
        id=next_id;
        ++next_id;
    }

    assert(id>=1 && id<=num_asm_tracking_data);

    //
    //

    static bool init=false;
    if (!init) {
        APPEND_M(str( ".data" ));
        APPEND_M(str( ".balign 8" ));

        APPEND_M(str( "track_asm_rax: .quad 0" ));

        //APPEND_M(str( ".global asm_tracking_data" ));
        //APPEND_M(str( "asm_tracking_data:" ));
        //for (int x=0;x<num_asm_tracking_data;++x) {
            //APPEND_M(str( ".quad 0" ));
        //}

        //APPEND_M(str( ".global asm_tracking_data_comments" ));
        //APPEND_M(str( "asm_tracking_data_comments:" ));
        //for (int x=0;x<num_asm_tracking_data;++x) {
            //APPEND_M(str( ".quad 0" ));
        //}

        APPEND_M(str( ".text" ));

        init=true;
    }

    string comment_label=m.alloc_label();
#ifdef CHIAOSX
    APPEND_M(str( ".text " ));
#else
    APPEND_M(str( ".text 1" ));
#endif
    APPEND_M(str( "#:", comment_label ));
    APPEND_M(str( ".string \"#\"", comment ));
    APPEND_M(str( ".text" ));

    string skip_label;
    if (!jump_to.empty()) {
        skip_label=m.alloc_label();
        APPEND_M(str( "JMP #", skip_label ));
    }

    string c_label;

    if (!jump_to.empty()) {
        c_label=m.alloc_label();
        APPEND_M(str( "#:", c_label ));
    }

    assert(!enable_threads); //this code isn't atomic

    APPEND_M(str( "MOV [track_asm_rax], RAX" ));
    APPEND_M(str( "MOV RAX, [asm_tracking_data+#]", to_hex(8*(id-1)) ));
    APPEND_M(str( "LEA RAX, [RAX+1]" ));
    APPEND_M(str( "MOV [asm_tracking_data+#], RAX", to_hex(8*(id-1)) ));
#ifdef CHIAOSX
    APPEND_M(str( "LEA RAX, [RIP+comment_label] " ));
#else
    APPEND_M(str( "MOV RAX, OFFSET FLAT:#", comment_label ));
#endif
    APPEND_M(str( "MOV [asm_tracking_data_comments+#], RAX", to_hex(8*(id-1)) ));
    APPEND_M(str( "MOV RAX, [track_asm_rax]" ));

    if (!jump_to.empty()) {
        APPEND_M(str( "JMP #", jump_to ));
        APPEND_M(str( "#:", skip_label ));
    }

    return c_label;
}

//16-byte aligned; value is in both lanes
string constant_address_uint64(uint64 value_bits_0, uint64 value_bits_1, bool use_brackets=true) {
    static map<pair<uint64, uint64>, string> constant_map;
    string& name=constant_map[make_pair(value_bits_0, value_bits_1)];

    if (name.empty()) {
        name=m.alloc_label();

#ifdef CHIAOSX
        APPEND_M(str( ".text " ));
#else
        APPEND_M(str( ".text 1" ));
#endif
        APPEND_M(str( ".balign 16" ));
        APPEND_M(str( "#:", name ));
        APPEND_M(str( ".quad #", to_hex(value_bits_0) )); //lane 0
        APPEND_M(str( ".quad #", to_hex(value_bits_1) )); //lane 1
        APPEND_M(str( ".text" ));
    }
#ifdef CHIAOSX
    return (use_brackets)? str( "[RIP+#]", name ) : name;
#else
    return (use_brackets)? str( "[#]", name ) : name;
#endif
}

string constant_address_double(double value_0, double value_1, bool use_brackets=true) {
    uint64 value_bits_0=*(uint64*)&value_0;
    uint64 value_bits_1=*(uint64*)&value_1;
    return constant_address_uint64(value_bits_0, value_bits_1, use_brackets);
}

string constant_address_avx512_uint64(array<uint64, 8> value, bool use_brackets=true) {
    static map<array<uint64, 8>, string> constant_map;
    string& name=constant_map[value];

    if (name.empty()) {
        name=m.alloc_label();

#ifdef CHIAOSX
        APPEND_M(str( ".text " ));
#else
        APPEND_M(str( ".text 1" ));
#endif
        APPEND_M(str( ".balign 64" ));
        APPEND_M(str( "#:", name ));
        for (int x=0;x<8;++x) {
            APPEND_M(str( ".quad #", to_hex(value[x]) )); //lane x
        }
        APPEND_M(str( ".text" ));
    }
#ifdef CHIAOSX
    return (use_brackets)? str( "ZMMWORD PTR [RIP+#]", name ) : name;
#else
    return (use_brackets)? str( "ZMMWORD PTR [#]", name ) : name;
#endif
}

string constant_address_avx512_uint64(uint64 value, bool use_brackets=true) {
    array<uint64, 8> value_array;
    for (int x=0;x<8;++x) {
        value_array[x]=value;
    }

    return constant_address_avx512_uint64(value_array);
}


}