func (h *Histogram) Init(buckets []int64, humanizeFn func(int64) string) {
l := len(buckets)
h.buckets = make([]int64, l+2)
copy(h.buckets[1:l], buckets)
h.buckets[0] = math.MinInt64
h.buckets[l] = math.MaxInt64
h.vals = make([]platform.AlignedInt64, l)
for i, _ := range h.vals {
h.vals[i] = platform.NewAlignedInt64(0)
}
if humanizeFn == nil {
humanizeFn = func(v int64) string { return fmt.Sprint(v) }
}
h.humanizeFn = humanizeFn
}
//NewAtomicMutationQueue allocates a new Atomic Mutation Queue and initializes it
func NewAtomicMutationQueue(numVbuckets uint16, maxLenPerVb int64) *atomicMutationQueue {
q := &atomicMutationQueue{head: make([]unsafe.Pointer, numVbuckets),
tail: make([]unsafe.Pointer, numVbuckets),
free: make([]*node, numVbuckets),
size: make([]platform.AlignedInt64, numVbuckets),
numVbuckets: numVbuckets,
maxLen: maxLenPerVb,
stopch: make([]StopChannel, numVbuckets),
}
var x uint16
for x = 0; x < numVbuckets; x++ {
node := &node{} //sentinel node for the queue
q.head[x] = unsafe.Pointer(node)
q.tail[x] = unsafe.Pointer(node)
q.free[x] = node
q.stopch[x] = make(StopChannel)
q.size[x] = platform.NewAlignedInt64(0)
}
return q
}
// NewServer creates a new queryport daemon.
func NewServer(
laddr string, callb RequestHandler,
config c.Config) (s *Server, err error) {
s = &Server{
laddr: laddr,
callb: callb,
killch: make(chan bool),
maxPayload: config["maxPayload"].Int(),
readDeadline: time.Duration(config["readDeadline"].Int()),
writeDeadline: time.Duration(config["writeDeadline"].Int()),
streamChanSize: config["streamChanSize"].Int(),
logPrefix: fmt.Sprintf("[Queryport %q]", laddr),
nConnections: platform.NewAlignedInt64(0),
}
if s.lis, err = net.Listen("tcp", laddr); err != nil {
logging.Errorf("%v failed starting %v !!\n", s.logPrefix, err)
return nil, err
}
go s.listener()
logging.Infof("%v started ...\n", s.logPrefix)
return s, nil
}
//NewForestDBSlice initiailizes a new slice with forestdb backend.
//Both main and back index gets initialized with default config.
//Slice methods are not thread-safe and application needs to
//handle the synchronization. The only exception being Insert and
//Delete can be called concurrently.
//Returns error in case slice cannot be initialized.
func NewForestDBSlice(path string, sliceId SliceId, idxDefnId common.IndexDefnId,
idxInstId common.IndexInstId, isPrimary bool,
sysconf common.Config, idxStats *IndexStats) (*fdbSlice, error) {
info, err := os.Stat(path)
if err != nil || err == nil && info.IsDir() {
os.Mkdir(path, 0777)
}
filepath := newFdbFile(path, false)
slice := &fdbSlice{}
slice.idxStats = idxStats
slice.get_bytes = platform.NewAlignedInt64(0)
slice.insert_bytes = platform.NewAlignedInt64(0)
slice.delete_bytes = platform.NewAlignedInt64(0)
slice.extraSnapDataSize = platform.NewAlignedInt64(0)
slice.flushedCount = platform.NewAlignedUint64(0)
slice.committedCount = platform.NewAlignedUint64(0)
config := forestdb.DefaultConfig()
config.SetDurabilityOpt(forestdb.DRB_ASYNC)
memQuota := sysconf["settings.memory_quota"].Uint64()
logging.Debugf("NewForestDBSlice(): buffer cache size %d", memQuota)
config.SetBufferCacheSize(memQuota)
logging.Debugf("NewForestDBSlice(): buffer cache size %d", memQuota)
prob := sysconf["settings.max_writer_lock_prob"].Int()
config.SetMaxWriterLockProb(uint8(prob))
logging.Debugf("NewForestDBSlice(): max writer lock prob %d", prob)
kvconfig := forestdb.DefaultKVStoreConfig()
retry:
if slice.dbfile, err = forestdb.Open(filepath, config); err != nil {
if err == forestdb.RESULT_NO_DB_HEADERS {
logging.Warnf("NewForestDBSlice(): Open failed with no_db_header error...Resetting the forestdb file")
os.Remove(filepath)
goto retry
}
return nil, err
}
slice.config = config
slice.sysconf = sysconf
//open a separate file handle for compaction
if slice.compactFd, err = forestdb.Open(filepath, config); err != nil {
return nil, err
}
config.SetOpenFlags(forestdb.OPEN_FLAG_RDONLY)
if slice.statFd, err = forestdb.Open(filepath, config); err != nil {
return nil, err
}
slice.numWriters = sysconf["numSliceWriters"].Int()
slice.main = make([]*forestdb.KVStore, slice.numWriters)
for i := 0; i < slice.numWriters; i++ {
if slice.main[i], err = slice.dbfile.OpenKVStore("main", kvconfig); err != nil {
return nil, err
}
}
//create a separate back-index for non-primary indexes
if !isPrimary {
slice.back = make([]*forestdb.KVStore, slice.numWriters)
for i := 0; i < slice.numWriters; i++ {
if slice.back[i], err = slice.dbfile.OpenKVStore("back", kvconfig); err != nil {
return nil, err
}
}
}
// Make use of default kvstore provided by forestdb
if slice.meta, err = slice.dbfile.OpenKVStore("default", kvconfig); err != nil {
return nil, err
}
slice.path = path
slice.currfile = filepath
slice.idxInstId = idxInstId
slice.idxDefnId = idxDefnId
slice.id = sliceId
sliceBufSize := sysconf["settings.sliceBufSize"].Uint64()
slice.cmdCh = make(chan interface{}, sliceBufSize)
slice.workerDone = make([]chan bool, slice.numWriters)
slice.stopCh = make([]DoneChannel, slice.numWriters)
slice.isPrimary = isPrimary
for i := 0; i < slice.numWriters; i++ {
slice.stopCh[i] = make(DoneChannel)
slice.workerDone[i] = make(chan bool)
go slice.handleCommandsWorker(i)
}
logging.Debugf("ForestDBSlice:NewForestDBSlice \n\t Created New Slice Id %v IndexInstId %v "+
"WriterThreads %v", sliceId, idxInstId, slice.numWriters)
slice.setCommittedCount()
return slice, nil
}
func (v *Int64Val) Init() {
v.val = new(platform.AlignedInt64)
*v.val = platform.NewAlignedInt64(0)
}