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) }