-
Notifications
You must be signed in to change notification settings - Fork 0
/
utils.go
170 lines (141 loc) · 2.71 KB
/
utils.go
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
169
170
package dcgm
/*
#include <stdlib.h>
#include "dcgm_structs.h"
*/
import "C"
import (
"fmt"
"math"
"unsafe"
)
const (
dcgmInt32Blank = 0x7ffffff0 // 2147483632
dcgmInt64Blank = 0x7ffffffffffffff0 // 9223372036854775792
)
func uintPtr(c C.uint) *uint {
i := uint(c)
return &i
}
func uintPtrInt(c C.int) *uint {
i := uint(c)
return &i
}
func uintPtrUnsafe(p unsafe.Pointer) *uint {
if p == nil {
return nil
}
uintP := (*uint)(unsafe.Pointer(p))
val := *uintP
return &val
}
func uint64Ptr(c C.longlong) *uint64 {
i := uint64(c)
return &i
}
func int64Ptr(c C.longlong) *int64 {
i := int64(c)
return &i
}
func uint64PtrUint(c C.uint) *uint64 {
i := uint64(c)
return &i
}
func uint64PtrUnsafe(p unsafe.Pointer) *uint64 {
if p == nil {
return nil
}
uintP := (*uint64)(unsafe.Pointer(p))
val := *uintP
return &val
}
func toInt64(c C.longlong) int64 {
i := int64(c)
return i
}
func dblToUint(val C.double) *uint {
i := uint(val)
return &i
}
func dblToFloat(val C.double) *float64 {
i := float64(val)
return &i
}
func dblToFloatUnsafe(val unsafe.Pointer) *float64 {
if val == nil {
return nil
}
dblP := (*C.double)(unsafe.Pointer(val))
floatP := float64(*dblP)
return &floatP
}
func stringPtr(c *C.char) *string {
s := C.GoString(c)
return &s
}
type DcgmError struct {
msg string // description of error
Code C.dcgmReturn_t // dcgmReturn_t value of error
}
func (e *DcgmError) Error() string { return e.msg }
func errorString(result C.dcgmReturn_t) error {
if result == C.DCGM_ST_OK {
return nil
}
err := C.GoString(C.errorString(result))
return fmt.Errorf("%v", err)
}
func freeCString(cStr *C.char) {
C.free(unsafe.Pointer(cStr))
}
func IsInt32Blank(value int) bool {
if value >= dcgmInt32Blank {
return true
}
return false
}
func IsInt64Blank(value int64) bool {
if value >= dcgmInt64Blank {
return true
}
return false
}
func blank64(val *int64) *int64 {
if val != nil && IsInt64Blank(*val) {
return nil
}
return val
}
func blank32(val *uint) *uint {
if val != nil && IsInt32Blank(int(*val)) {
return nil
}
return val
}
func makeVersion1(struct_type uintptr) C.uint {
version := C.uint(struct_type | 1<<24)
return version
}
func makeVersion2(struct_type uintptr) C.uint {
version := C.uint(struct_type | 2<<24)
return version
}
func makeVersion3(struct_type uintptr) C.uint {
version := C.uint(struct_type | 3<<24)
return version
}
func makeVersion4(struct_type uintptr) C.uint {
version := C.uint(struct_type | 4<<24)
return version
}
func makeVersion8(struct_type uintptr) C.uint {
version := C.uint(struct_type | 8<<24)
return version
}
func roundFloat(f *float64) *float64 {
var val float64
if f != nil {
val = math.Round(*f)
}
return &val
}