Add files using upload-large-folder tool

SPANN/AnnService/inc/Core/Common/BKTree.h

@@ -0,0 +1,814 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_BKTREE_H_
+#define _SPTAG_COMMON_BKTREE_H_
+
+#include <stack>
+#include <string>
+#include <vector>
+#include <mutex>
+#include <shared_mutex>
+#include "inc/Core/VectorIndex.h"
+
+#include "CommonUtils.h"
+#include "QueryResultSet.h"
+#include "WorkSpace.h"
+#include "Dataset.h"
+#include "DistanceUtils.h"
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        // node type for storing BKT
+        struct BKTNode
+        {
+            SizeType centerid;
+            SizeType childStart;
+            SizeType childEnd;
+
+            BKTNode(SizeType cid = -1) : centerid(cid), childStart(-1), childEnd(-1) {}
+        };
+
+        template <typename T>
+        struct KmeansArgs {
+            int _K;
+            int _DK;
+            DimensionType _D;
+            DimensionType _RD;
+            int _T;
+            DistCalcMethod _M;
+            T* centers;
+            T* newTCenters;
+            SizeType* counts;
+            float* newCenters;
+            SizeType* newCounts;
+            int* label;
+            SizeType* clusterIdx;
+            float* clusterDist;
+            float* weightedCounts;
+            float* newWeightedCounts;
+            std::function<float(const T*, const T*, DimensionType)> fComputeDistance;
+            const std::shared_ptr<IQuantizer>& m_pQuantizer;
+
+            KmeansArgs(int k, DimensionType dim, SizeType datasize, int threadnum, DistCalcMethod distMethod, const std::shared_ptr<IQuantizer>& quantizer = nullptr) : _K(k), _DK(k), _D(dim), _RD(dim), _T(threadnum), _M(distMethod), m_pQuantizer(quantizer){
+                if (m_pQuantizer) {
+                    _RD = m_pQuantizer->ReconstructDim();
+                    fComputeDistance = m_pQuantizer->DistanceCalcSelector<T>(distMethod);
+                }
+                else {
+                    fComputeDistance = COMMON::DistanceCalcSelector<T>(distMethod);
+                }
+
+                centers = (T*)ALIGN_ALLOC(sizeof(T) * _K * _D);
+                newTCenters = (T*)ALIGN_ALLOC(sizeof(T) * _K * _D);
+                counts = new SizeType[_K];
+                newCenters = new float[_T * _K * _RD];
+                newCounts = new SizeType[_T * _K];
+                label = new int[datasize];
+                clusterIdx = new SizeType[_T * _K];
+                clusterDist = new float[_T * _K];
+                weightedCounts = new float[_K];
+                newWeightedCounts = new float[_T * _K];
+            }
+
+            ~KmeansArgs() {
+                ALIGN_FREE(centers);
+                ALIGN_FREE(newTCenters);
+                delete[] counts;
+                delete[] newCenters;
+                delete[] newCounts;
+                delete[] label;
+                delete[] clusterIdx;
+                delete[] clusterDist;
+                delete[] weightedCounts;
+                delete[] newWeightedCounts;
+            }
+
+            inline void ClearCounts() {
+                memset(newCounts, 0, sizeof(SizeType) * _T * _K);
+                memset(newWeightedCounts, 0, sizeof(float) * _T * _K);
+            }
+
+            inline void ClearCenters() {
+                memset(newCenters, 0, sizeof(float) * _T * _K * _RD);
+            }
+
+            inline void ClearDists(float dist) {
+                for (int i = 0; i < _T * _K; i++) {
+                    clusterIdx[i] = -1;
+                    clusterDist[i] = dist;
+                }
+            }
+
+            void Shuffle(std::vector<SizeType>& indices, SizeType first, SizeType last) {
+                SizeType* pos = new SizeType[_K];
+                pos[0] = first;
+                for (int k = 1; k < _K; k++) pos[k] = pos[k - 1] + newCounts[k - 1];
+
+                for (int k = 0; k < _K; k++) {
+                    if (counts[k] == 0) continue;
+                    SizeType i = pos[k];
+                    while (newCounts[k] > 0) {
+                        SizeType swapid = pos[label[i]] + newCounts[label[i]] - 1;
+                        newCounts[label[i]]--;
+                        std::swap(indices[i], indices[swapid]);
+                        std::swap(label[i], label[swapid]);
+                    }
+                    while (indices[i] != clusterIdx[k]) i++;
+                    std::swap(indices[i], indices[pos[k] + counts[k] - 1]);
+                }
+                delete[] pos;
+            }
+        };
+        template<typename T>
+        void RefineLambda(KmeansArgs<T>& args, float& lambda, int size)
+        {
+            int maxcluster = -1;
+            SizeType maxCount = 0;
+            for (int k = 0; k < args._DK; k++) {
+                if (args.counts[k] > maxCount && args.newCounts[k] > 0)
+                {
+                    maxcluster = k;
+                    maxCount = args.counts[k];
+                }
+            }
+
+            float avgDist = args.newWeightedCounts[maxcluster] / args.newCounts[maxcluster];
+            //lambda = avgDist / 10 / args.counts[maxcluster];
+            //lambda = (args.clusterDist[maxcluster] - avgDist) / args.newCounts[maxcluster];
+            lambda = (args.clusterDist[maxcluster] - avgDist) / size;
+            if (lambda < 0) lambda = 0;
+        }
+
+        template <typename T, typename R>
+        float RefineCenters(const Dataset<T>& data, KmeansArgs<T>& args)
+        {
+            int maxcluster = -1;
+            SizeType maxCount = 0;
+            for (int k = 0; k < args._DK; k++) {
+                if (args.counts[k] > maxCount && args.newCounts[k] > 0 && DistanceUtils::ComputeDistance((T*)data[args.clusterIdx[k]], args.centers + k * args._D, args._D, DistCalcMethod::L2) > 1e-6)
+                {
+                    maxcluster = k;
+                    maxCount = args.counts[k];
+                }
+            }
+
+            if (maxcluster != -1 && (args.clusterIdx[maxcluster] < 0 || args.clusterIdx[maxcluster] >= data.R()))
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Debug, "maxcluster:%d(%d) Error dist:%f\n", maxcluster, args.newCounts[maxcluster], args.clusterDist[maxcluster]);
+
+            float diff = 0;
+            std::vector<R> reconstructVector(args._RD, 0);
+            for (int k = 0; k < args._DK; k++) {
+                T* TCenter = args.newTCenters + k * args._D;
+                if (args.counts[k] == 0) {
+                    if (maxcluster != -1) {
+                        //int nextid = Utils::rand_int(last, first);
+                        //while (args.label[nextid] != maxcluster) nextid = Utils::rand_int(last, first);
+                        SizeType nextid = args.clusterIdx[maxcluster];
+                        std::memcpy(TCenter, data[nextid], sizeof(T)*args._D);
+                    }
+                    else {
+                        std::memcpy(TCenter, args.centers + k * args._D, sizeof(T)*args._D);
+                    }
+                }
+                else {
+                    float* currCenters = args.newCenters + k * args._RD;
+                    for (DimensionType j = 0; j < args._RD; j++) {
+                        currCenters[j] /= args.counts[k];
+                    }
+                    
+                    if (args._M == DistCalcMethod::Cosine) {
+                        COMMON::Utils::Normalize(currCenters, args._RD, COMMON::Utils::GetBase<T>());
+                    }
+                    
+                    if (args.m_pQuantizer) {
+                        for (DimensionType j = 0; j < args._RD; j++) reconstructVector[j] = (R)(currCenters[j]);
+                        args.m_pQuantizer->QuantizeVector(reconstructVector.data(), (uint8_t*)TCenter);
+                    }
+                    else {
+                        for (DimensionType j = 0; j < args._D; j++) TCenter[j] = (T)(currCenters[j]);
+                    }
+                }
+                diff += DistanceUtils::ComputeDistance(TCenter, args.centers + k * args._D, args._D, DistCalcMethod::L2);
+            }
+            return diff;
+        }
+
+#if defined(NEWGPU)
+
+#include "inc/Core/Common/cuda/Kmeans.hxx"
+
+        template <typename T, typename R>
+        inline float KmeansAssign(const Dataset<T>& data,
+            std::vector<SizeType>& indices,
+            const SizeType first, const SizeType last, KmeansArgs<T>& args,
+            const bool updateCenters, float lambda) {
+            float currDist = 0;
+            SizeType totalSize = last - first;
+
+// TODO - compile-time options for MAX_DIM and metric
+            computeKmeansGPU<T, float, 100>(data, indices, first, last, args._K, args._D,
+                                args._DK, lambda, args.centers, args.label, args.counts, args.newCounts, args.newCenters, 
+                                args.clusterIdx, args.clusterDist, args.weightedCounts, args.newWeightedCounts, 0, updateCenters);
+        }                               
+
+#else
+
+        template <typename T, typename R>
+        inline float KmeansAssign(const Dataset<T>& data,
+            std::vector<SizeType>& indices,
+            const SizeType first, const SizeType last, KmeansArgs<T>& args, 
+            const bool updateCenters, float lambda) {
+            float currDist = 0;
+            SizeType subsize = (last - first - 1) / args._T + 1;
+
+#pragma omp parallel for num_threads(args._T) shared(data, indices) reduction(+:currDist)
+            for (int tid = 0; tid < args._T; tid++)
+            {
+                SizeType istart = first + tid * subsize;
+                SizeType iend = min(first + (tid + 1) * subsize, last);
+                SizeType *inewCounts = args.newCounts + tid * args._K;
+                float *inewCenters = args.newCenters + tid * args._K * args._RD;
+                SizeType * iclusterIdx = args.clusterIdx + tid * args._K;
+                float * iclusterDist = args.clusterDist + tid * args._K;
+                float * iweightedCounts = args.newWeightedCounts + tid * args._K;
+                float idist = 0;
+                R* reconstructVector = nullptr;
+                if (args.m_pQuantizer) reconstructVector = (R*)ALIGN_ALLOC(args.m_pQuantizer->ReconstructSize());
+
+                for (SizeType i = istart; i < iend; i++) {
+                    int clusterid = 0;
+                    float smallestDist = MaxDist;
+                    for (int k = 0; k < args._DK; k++) {
+                        float dist = args.fComputeDistance(data[indices[i]], args.centers + k*args._D, args._D) + lambda*args.counts[k];
+                        if (dist > -MaxDist && dist < smallestDist) {
+                            clusterid = k; smallestDist = dist;
+                        }
+                    }
+                    args.label[i] = clusterid;
+                    inewCounts[clusterid]++;
+                    iweightedCounts[clusterid] += smallestDist;
+                    idist += smallestDist;
+                    if (updateCenters) {
+                        if (args.m_pQuantizer) {
+                            args.m_pQuantizer->ReconstructVector((const uint8_t*)data[indices[i]], reconstructVector);
+                        }
+                        else {
+                            reconstructVector = (R*)data[indices[i]];
+                        }
+                        float* center = inewCenters + clusterid*args._RD;
+                        for (DimensionType j = 0; j < args._RD; j++) center[j] += reconstructVector[j];
+
+                        if (smallestDist > iclusterDist[clusterid]) {
+                            iclusterDist[clusterid] = smallestDist;
+                            iclusterIdx[clusterid] = indices[i];
+                        }
+                    }
+                    else {
+                        if (smallestDist <= iclusterDist[clusterid]) {
+                            iclusterDist[clusterid] = smallestDist;
+                            iclusterIdx[clusterid] = indices[i];
+                        }
+                    }
+                }
+                if (args.m_pQuantizer) ALIGN_FREE(reconstructVector);
+                currDist += idist;
+            }
+
+            for (int i = 1; i < args._T; i++) {
+                for (int k = 0; k < args._DK; k++) {
+                    args.newCounts[k] += args.newCounts[i * args._K + k];
+                    args.newWeightedCounts[k] += args.newWeightedCounts[i * args._K + k];
+                }
+            }
+
+            if (updateCenters) {
+                for (int i = 1; i < args._T; i++) {
+                    float* currCenter = args.newCenters + i*args._K*args._RD;
+                    for (size_t j = 0; j < ((size_t)args._DK) * args._RD; j++) args.newCenters[j] += currCenter[j];
+
+                    for (int k = 0; k < args._DK; k++) {
+                        if (args.clusterIdx[i*args._K + k] != -1 && args.clusterDist[i*args._K + k] > args.clusterDist[k]) {
+                            args.clusterDist[k] = args.clusterDist[i*args._K + k];
+                            args.clusterIdx[k] = args.clusterIdx[i*args._K + k];
+                        }
+                    }
+                }
+            }
+            else {
+                for (int i = 1; i < args._T; i++) {
+                    for (int k = 0; k < args._DK; k++) {
+                        if (args.clusterIdx[i*args._K + k] != -1 && args.clusterDist[i*args._K + k] <= args.clusterDist[k]) {
+                            args.clusterDist[k] = args.clusterDist[i*args._K + k];
+                            args.clusterIdx[k] = args.clusterIdx[i*args._K + k];
+                        }
+                    }
+                }
+            }
+            return currDist;
+        }
+
+#endif
+
+
+        template <typename T, typename R>
+        inline float InitCenters(const Dataset<T>& data, 
+            std::vector<SizeType>& indices, const SizeType first, const SizeType last, 
+            KmeansArgs<T>& args, int samples, int tryIters) {
+            SizeType batchEnd = min(first + samples, last);
+            float lambda = 0, currDist, minClusterDist = MaxDist;
+            for (int numKmeans = 0; numKmeans < tryIters; numKmeans++) {
+                for (int k = 0; k < args._DK; k++) {
+                    SizeType randid = COMMON::Utils::rand(last, first);
+                    std::memcpy(args.centers + k*args._D, data[indices[randid]], sizeof(T)*args._D);
+                }
+                args.ClearCounts();
+                args.ClearDists(-MaxDist);
+                currDist = KmeansAssign<T, R>(data, indices, first, batchEnd, args, true, 0);
+                if (currDist < minClusterDist) {
+                    minClusterDist = currDist;
+                    memcpy(args.newTCenters, args.centers, sizeof(T)*args._K*args._D);
+                    memcpy(args.counts, args.newCounts, sizeof(SizeType) * args._K);
+
+                    RefineLambda(args, lambda, batchEnd - first);
+                }
+            }
+            return lambda;
+        }
+
+        template <typename T, typename R>
+        float TryClustering(const Dataset<T>& data,
+            std::vector<SizeType>& indices, const SizeType first, const SizeType last,
+            KmeansArgs<T>& args, int samples = 1000, float lambdaFactor = 100.0f, bool debug = false, IAbortOperation* abort = nullptr) {
+
+            float adjustedLambda = InitCenters<T, R>(data, indices, first, last, args, samples, 3);
+            if (abort && abort->ShouldAbort()) return 0;
+
+            SizeType batchEnd = min(first + samples, last);
+            float currDiff, currDist, minClusterDist = MaxDist;
+            int noImprovement = 0;
+            float originalLambda = COMMON::Utils::GetBase<T>() * COMMON::Utils::GetBase<T>() / lambdaFactor / (batchEnd - first);
+            for (int iter = 0; iter < 100; iter++) {
+                std::memcpy(args.centers, args.newTCenters, sizeof(T)*args._K*args._D);
+                std::shuffle(indices.begin() + first, indices.begin() + last, rg);
+
+                args.ClearCenters();
+                args.ClearCounts();
+                args.ClearDists(-MaxDist);
+                currDist = KmeansAssign<T, R>(data, indices, first, batchEnd, args, true, min(adjustedLambda, originalLambda));
+                std::memcpy(args.counts, args.newCounts, sizeof(SizeType) * args._K);
+
+                if (currDist < minClusterDist) {
+                    noImprovement = 0;
+                    minClusterDist = currDist;
+                }
+                else {
+                    noImprovement++;
+                }
+
+                /*
+                if (debug) {
+                    std::string log = "";
+                    for (int k = 0; k < args._DK; k++) {
+                        log += std::to_string(args.counts[k]) + " ";
+                    }
+                    SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "iter %d dist:%f lambda:(%f,%f) counts:%s\n", iter, currDist, originalLambda, adjustedLambda, log.c_str());
+                }
+                */
+
+                currDiff = RefineCenters<T, R>(data, args);
+                //if (debug) SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "iter %d dist:%f diff:%f\n", iter, currDist, currDiff);
+
+                if (abort && abort->ShouldAbort()) return 0;
+                if (currDiff < 1e-3 || noImprovement >= 5) break;
+            }
+
+            args.ClearCounts();
+            args.ClearDists(MaxDist);
+            currDist = KmeansAssign<T, R>(data, indices, first, last, args, false, 0);
+            for (int k = 0; k < args._DK; k++) {
+                if (args.clusterIdx[k] != -1) std::memcpy(args.centers + k * args._D, data[args.clusterIdx[k]], sizeof(T) * args._D);
+            }
+
+            args.ClearCounts();
+            args.ClearDists(MaxDist);
+            currDist = KmeansAssign<T, R>(data, indices, first, last, args, false, 0);
+            std::memcpy(args.counts, args.newCounts, sizeof(SizeType) * args._K);
+
+            SizeType maxCount = 0, minCount = (std::numeric_limits<SizeType>::max)(), availableClusters = 0;
+            float CountStd = 0.0, CountAvg = (last - first) * 1.0f / args._DK;
+            for (int i = 0; i < args._DK; i++) {
+                if (args.counts[i] > maxCount) maxCount = args.counts[i];
+                if (args.counts[i] < minCount) minCount = args.counts[i];
+                CountStd += (args.counts[i] - CountAvg) * (args.counts[i] - CountAvg);
+                if (args.counts[i] > 0) availableClusters++;
+            }
+            CountStd = sqrt(CountStd / args._DK) / CountAvg;
+            if (debug) SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Lambda:min(%g,%g) Max:%d Min:%d Avg:%f Std/Avg:%f Dist:%f NonZero/Total:%d/%d\n", originalLambda, adjustedLambda, maxCount, minCount, CountAvg, CountStd, currDist, availableClusters, args._DK);
+
+            return CountStd;
+        }
+
+        template <typename T>
+        float DynamicFactorSelect(const Dataset<T> & data,
+            std::vector<SizeType> & indices, const SizeType first, const SizeType last,
+            KmeansArgs<T> & args, int samples = 1000) {
+
+            float bestLambdaFactor = 100.0f, bestCountStd = (std::numeric_limits<float>::max)();
+            for (float lambdaFactor = 0.001f; lambdaFactor <= 1000.0f + 1e-3; lambdaFactor *= 10) {
+                float CountStd = 0.0;
+                if (args.m_pQuantizer)
+                {
+                    switch (args.m_pQuantizer->GetReconstructType())
+                    {
+#define DefineVectorValueType(Name, Type) \
+case VectorValueType::Name: \
+CountStd = TryClustering<T, Type>(data, indices, first, last, args, samples, lambdaFactor, true); \
+break;
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineVectorValueType
+
+                    default: break;
+                    }
+                }
+                else
+                {
+                    CountStd = TryClustering<T, T>(data, indices, first, last, args, samples, lambdaFactor, true);
+                }
+
+                if (CountStd < bestCountStd) {
+                    bestLambdaFactor = lambdaFactor;
+                    bestCountStd = CountStd;
+                }
+            }
+            /*
+            std::vector<float> tries(16, 0);
+            for (int i = 0; i < 8; i++) {
+                tries[i] = bestLambdaFactor * (i + 2) / 10;
+                tries[8 + i] = bestLambdaFactor * (i + 2);
+            }
+            for (float lambdaFactor : tries) {
+                float CountStd = TryClustering(data, indices, first, last, args, samples, lambdaFactor, true);
+                if (CountStd < bestCountStd) {
+                    bestLambdaFactor = lambdaFactor;
+                    bestCountStd = CountStd;
+                }
+            }
+            */
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Best Lambda Factor:%f\n", bestLambdaFactor);
+            return bestLambdaFactor;
+        }
+
+        template <typename T>
+        int KmeansClustering(const Dataset<T>& data,
+            std::vector<SizeType>& indices, const SizeType first, const SizeType last, 
+            KmeansArgs<T>& args, int samples = 1000, float lambdaFactor = 100.0f, bool debug = false, IAbortOperation* abort = nullptr) {
+            
+            if (args.m_pQuantizer)
+            {
+                switch (args.m_pQuantizer->GetReconstructType())
+                {
+#define DefineVectorValueType(Name, Type) \
+case VectorValueType::Name: \
+TryClustering<T, Type>(data, indices, first, last, args, samples, lambdaFactor, debug, abort); \
+break;
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineVectorValueType
+
+                default: break;
+                }
+            }
+            else
+            {
+                TryClustering<T, T>(data, indices, first, last, args, samples, lambdaFactor, debug, abort);
+            }
+
+            if (abort && abort->ShouldAbort()) return 1;
+
+            int numClusters = 0;
+            for (int i = 0; i < args._K; i++) if (args.counts[i] > 0) numClusters++;
+
+            if (numClusters <= 1) return numClusters;
+
+            args.Shuffle(indices, first, last);
+            return numClusters;
+        }
+
+        class BKTree
+        {
+        public:
+            BKTree(): m_iTreeNumber(1), m_iBKTKmeansK(32), m_iBKTLeafSize(8), m_iSamples(1000), m_fBalanceFactor(-1.0f), m_bfs(0), m_lock(new std::shared_timed_mutex), m_pQuantizer(nullptr) {}
+            
+            BKTree(const BKTree& other): m_iTreeNumber(other.m_iTreeNumber), 
+                                   m_iBKTKmeansK(other.m_iBKTKmeansK), 
+                                   m_iBKTLeafSize(other.m_iBKTLeafSize),
+                                   m_iSamples(other.m_iSamples),
+                                   m_fBalanceFactor(other.m_fBalanceFactor),
+                                   m_lock(new std::shared_timed_mutex),
+                                   m_pQuantizer(other.m_pQuantizer) {}
+            ~BKTree() {}
+
+            inline const BKTNode& operator[](SizeType index) const { return m_pTreeRoots[index]; }
+            inline BKTNode& operator[](SizeType index) { return m_pTreeRoots[index]; }
+
+            inline SizeType size() const { return (SizeType)m_pTreeRoots.size(); }
+            
+            inline SizeType sizePerTree() const {
+                std::shared_lock<std::shared_timed_mutex> lock(*m_lock);
+                return (SizeType)m_pTreeRoots.size() - m_pTreeStart.back(); 
+            }
+
+            inline const std::unordered_map<SizeType, SizeType>& GetSampleMap() const { return m_pSampleCenterMap; }
+
+            inline void SwapTree(BKTree& newTrees)
+            {
+                m_pTreeRoots.swap(newTrees.m_pTreeRoots);
+                m_pTreeStart.swap(newTrees.m_pTreeStart);
+                m_pSampleCenterMap.swap(newTrees.m_pSampleCenterMap);
+            }
+
+            template <typename T>
+            void Rebuild(const Dataset<T>& data, DistCalcMethod distMethod, IAbortOperation* abort)
+            {
+                BKTree newTrees(*this);
+                newTrees.BuildTrees<T>(data, distMethod, 1, nullptr, nullptr, false, abort);
+
+                std::unique_lock<std::shared_timed_mutex> lock(*m_lock);
+                m_pTreeRoots.swap(newTrees.m_pTreeRoots);
+                m_pTreeStart.swap(newTrees.m_pTreeStart);
+                m_pSampleCenterMap.swap(newTrees.m_pSampleCenterMap);
+            }
+
+            template <typename T>
+            void BuildTrees(const Dataset<T>& data, DistCalcMethod distMethod, int numOfThreads, 
+                std::vector<SizeType>* indices = nullptr, std::vector<SizeType>* reverseIndices = nullptr, 
+                bool dynamicK = false, IAbortOperation* abort = nullptr)
+            {
+                struct  BKTStackItem {
+                    SizeType index, first, last;
+                    bool debug;
+                    BKTStackItem(SizeType index_, SizeType first_, SizeType last_, bool debug_ = false) : index(index_), first(first_), last(last_), debug(debug_) {}
+                };
+                std::stack<BKTStackItem> ss;
+
+                std::vector<SizeType> localindices;
+                if (indices == nullptr) {
+                    localindices.resize(data.R());
+                    for (SizeType i = 0; i < localindices.size(); i++) localindices[i] = i;
+                }
+                else {
+                    localindices.assign(indices->begin(), indices->end());
+                }
+                KmeansArgs<T> args(m_iBKTKmeansK, data.C(), (SizeType)localindices.size(), numOfThreads, distMethod, m_pQuantizer);
+
+                if (m_fBalanceFactor < 0) m_fBalanceFactor = DynamicFactorSelect(data, localindices, 0, (SizeType)localindices.size(), args, m_iSamples);
+
+                m_pSampleCenterMap.clear();
+                for (char i = 0; i < m_iTreeNumber; i++)
+                {
+                    std::shuffle(localindices.begin(), localindices.end(), rg);
+
+                    m_pTreeStart.push_back((SizeType)m_pTreeRoots.size());
+                    m_pTreeRoots.emplace_back((SizeType)localindices.size());
+                    SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Start to build BKTree %d\n", i + 1);
+
+                    ss.push(BKTStackItem(m_pTreeStart[i], 0, (SizeType)localindices.size(), true));
+                    while (!ss.empty()) {
+                        if (abort && abort->ShouldAbort()) return;
+
+                        BKTStackItem item = ss.top(); ss.pop();
+                        m_pTreeRoots[item.index].childStart = (SizeType)m_pTreeRoots.size();
+                        if (item.last - item.first <= m_iBKTLeafSize) {
+                            for (SizeType j = item.first; j < item.last; j++) {
+                                SizeType cid = (reverseIndices == nullptr)? localindices[j]: reverseIndices->at(localindices[j]);
+                                m_pTreeRoots.emplace_back(cid);
+                            }
+                        }
+                        else { // clustering the data into BKTKmeansK clusters
+                            if (dynamicK) {
+                                args._DK = std::min<int>((item.last - item.first) / m_iBKTLeafSize + 1, m_iBKTKmeansK);
+                                args._DK = std::max<int>(args._DK, 2);
+                            }
+
+                            int numClusters = KmeansClustering(data, localindices, item.first, item.last, args, m_iSamples, m_fBalanceFactor, item.debug, abort);
+                            if (numClusters <= 1) {
+                                SizeType end = min(item.last + 1, (SizeType)localindices.size());
+                                std::sort(localindices.begin() + item.first, localindices.begin() + end);
+                                m_pTreeRoots[item.index].centerid = (reverseIndices == nullptr) ? localindices[item.first] : reverseIndices->at(localindices[item.first]);
+                                m_pTreeRoots[item.index].childStart = -m_pTreeRoots[item.index].childStart;
+                                for (SizeType j = item.first + 1; j < end; j++) {
+                                    SizeType cid = (reverseIndices == nullptr) ? localindices[j] : reverseIndices->at(localindices[j]);
+                                    m_pTreeRoots.emplace_back(cid);
+                                    m_pSampleCenterMap[cid] = m_pTreeRoots[item.index].centerid;
+                                }
+                                m_pSampleCenterMap[-1 - m_pTreeRoots[item.index].centerid] = item.index;
+                            }
+                            else {
+                                SizeType maxCount = 0;
+                                for (int k = 0; k < m_iBKTKmeansK; k++) if (args.counts[k] > maxCount) maxCount = args.counts[k];
+                                for (int k = 0; k < m_iBKTKmeansK; k++) {
+                                    if (args.counts[k] == 0) continue;
+                                    SizeType cid = (reverseIndices == nullptr) ? localindices[item.first + args.counts[k] - 1] : reverseIndices->at(localindices[item.first + args.counts[k] - 1]);
+                                    m_pTreeRoots.emplace_back(cid);
+                                    if (args.counts[k] > 1) ss.push(BKTStackItem((SizeType)(m_pTreeRoots.size() - 1), item.first, item.first + args.counts[k] - 1, item.debug && (args.counts[k] == maxCount)));
+                                    item.first += args.counts[k];
+                                }
+                            }
+                        }
+                        m_pTreeRoots[item.index].childEnd = (SizeType)m_pTreeRoots.size();
+                    }
+                    m_pTreeRoots.emplace_back(-1);
+                    SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "%d BKTree built, %zu %zu\n", i + 1, m_pTreeRoots.size() - m_pTreeStart[i], localindices.size());
+                }
+            }
+
+            inline std::uint64_t BufferSize() const
+            {
+                return sizeof(int) + sizeof(SizeType) * m_iTreeNumber +
+                    sizeof(SizeType) + sizeof(BKTNode) * m_pTreeRoots.size();
+            }
+
+            ErrorCode SaveTrees(std::shared_ptr<Helper::DiskIO> p_out) const
+            {
+                std::shared_lock<std::shared_timed_mutex> lock(*m_lock);
+                IOBINARY(p_out, WriteBinary, sizeof(m_iTreeNumber), (char*)&m_iTreeNumber);
+                IOBINARY(p_out, WriteBinary, sizeof(SizeType) * m_iTreeNumber, (char*)m_pTreeStart.data());
+                SizeType treeNodeSize = (SizeType)m_pTreeRoots.size();
+                IOBINARY(p_out, WriteBinary, sizeof(treeNodeSize), (char*)&treeNodeSize);
+                IOBINARY(p_out, WriteBinary, sizeof(BKTNode) * treeNodeSize, (char*)m_pTreeRoots.data());
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Save BKT (%d,%d) Finish!\n", m_iTreeNumber, treeNodeSize);
+                return ErrorCode::Success;
+            }
+
+            ErrorCode SaveTrees(std::string sTreeFileName) const
+            {
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Save BKT to %s\n", sTreeFileName.c_str());
+                auto ptr = f_createIO();
+                if (ptr == nullptr || !ptr->Initialize(sTreeFileName.c_str(), std::ios::binary | std::ios::out)) return ErrorCode::FailedCreateFile;
+                return SaveTrees(ptr);
+            }
+
+            ErrorCode LoadTrees(char* pBKTMemFile)
+            {
+                m_iTreeNumber = *((int*)pBKTMemFile);
+                pBKTMemFile += sizeof(int);
+                m_pTreeStart.resize(m_iTreeNumber);
+                memcpy(m_pTreeStart.data(), pBKTMemFile, sizeof(SizeType) * m_iTreeNumber);
+                pBKTMemFile += sizeof(SizeType)*m_iTreeNumber;
+
+                SizeType treeNodeSize = *((SizeType*)pBKTMemFile);
+                pBKTMemFile += sizeof(SizeType);
+                m_pTreeRoots.resize(treeNodeSize);
+                memcpy(m_pTreeRoots.data(), pBKTMemFile, sizeof(BKTNode) * treeNodeSize);
+                if (m_pTreeRoots.size() > 0 && m_pTreeRoots.back().centerid != -1) m_pTreeRoots.emplace_back(-1);
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Load BKT (%d,%d) Finish!\n", m_iTreeNumber, treeNodeSize);
+                return ErrorCode::Success;
+            }
+
+            ErrorCode LoadTrees(std::shared_ptr<Helper::DiskIO> p_input)
+            {
+                IOBINARY(p_input, ReadBinary, sizeof(m_iTreeNumber), (char*)&m_iTreeNumber);
+                m_pTreeStart.resize(m_iTreeNumber);
+                IOBINARY(p_input, ReadBinary, sizeof(SizeType) * m_iTreeNumber, (char*)m_pTreeStart.data());
+
+                SizeType treeNodeSize;
+                IOBINARY(p_input, ReadBinary, sizeof(treeNodeSize), (char*)&treeNodeSize);
+                m_pTreeRoots.resize(treeNodeSize);
+                IOBINARY(p_input, ReadBinary, sizeof(BKTNode) * treeNodeSize, (char*)m_pTreeRoots.data());
+
+                if (m_pTreeRoots.size() > 0 && m_pTreeRoots.back().centerid != -1) m_pTreeRoots.emplace_back(-1);
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Load BKT (%d,%d) Finish!\n", m_iTreeNumber, treeNodeSize);
+                return ErrorCode::Success;
+            }
+
+            ErrorCode LoadTrees(std::string sTreeFileName)
+            {
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Load BKT From %s\n", sTreeFileName.c_str());
+                auto ptr = f_createIO();
+                if (ptr == nullptr || !ptr->Initialize(sTreeFileName.c_str(), std::ios::binary | std::ios::in)) return ErrorCode::FailedOpenFile;
+                return LoadTrees(ptr);
+            }
+
+            template <typename T>
+            void InitSearchTrees(const Dataset<T>& data, std::function<float(const T*, const T*, DimensionType)> fComputeDistance, COMMON::QueryResultSet<T> &p_query, COMMON::WorkSpace &p_space) const
+            {
+                for (char i = 0; i < m_iTreeNumber; i++) {
+                    const BKTNode& node = m_pTreeRoots[m_pTreeStart[i]];
+                    if (node.childStart < 0) {
+                        p_space.m_SPTQueue.insert(NodeDistPair(m_pTreeStart[i], fComputeDistance(p_query.GetQuantizedTarget(), data[node.centerid], data.C())));
+                    } else if (m_bfs) {
+                        float FactorQ = 1.1f;
+                        int MaxBFSNodes = 100;
+                        p_space.m_currBSPTQueue.Resize(MaxBFSNodes); p_space.m_nextBSPTQueue.Resize(MaxBFSNodes);
+                        Heap<NodeDistPair>* p_curr = &p_space.m_currBSPTQueue, * p_next = &p_space.m_nextBSPTQueue;
+                        p_curr->Top().distance = 1e9;
+                       
+                        for (SizeType begin = node.childStart; begin < node.childEnd; begin++) {
+                            _mm_prefetch((const char*)(data[m_pTreeRoots[begin].centerid]), _MM_HINT_T0);
+                        }
+                        
+                        for (SizeType begin = node.childStart; begin < node.childEnd; begin++) {
+                            SizeType index = m_pTreeRoots[begin].centerid;
+                            float dist = fComputeDistance(p_query.GetQuantizedTarget(), data[index], data.C());
+                            if (dist <= FactorQ * p_curr->Top().distance && p_curr->size() < MaxBFSNodes) {
+                                p_curr->insert(NodeDistPair(begin, dist));
+                            }
+                            else {
+                                p_space.m_SPTQueue.insert(NodeDistPair(begin, dist));
+                            }
+                        }
+
+                        for (int level = 1; level <= m_bfs; level++) {
+                            p_next->Top().distance = 1e9;
+                            while (!p_curr->empty()) {
+                                NodeDistPair tmp = p_curr->pop();
+                                const BKTNode& tnode = m_pTreeRoots[tmp.node];
+                                if (tnode.childStart < 0) {
+                                    p_space.m_SPTQueue.insert(tmp);
+                                }
+                                else {
+                                    for (SizeType begin = tnode.childStart; begin < tnode.childEnd; begin++) {
+                                        _mm_prefetch((const char*)(data[m_pTreeRoots[begin].centerid]), _MM_HINT_T0);
+                                    }
+                                    if (!p_space.CheckAndSet(tnode.centerid)) {
+                                        p_space.m_NGQueue.insert(NodeDistPair(tnode.centerid, tmp.distance));
+                                    }
+                                    for (SizeType begin = tnode.childStart; begin < tnode.childEnd; begin++) {
+                                        SizeType index = m_pTreeRoots[begin].centerid;
+                                        float dist = fComputeDistance(p_query.GetQuantizedTarget(), data[index], data.C());
+                                        if (dist <= FactorQ * p_next->Top().distance && p_next->size() < MaxBFSNodes) {
+                                            p_next->insert(NodeDistPair(begin, dist));
+                                        }
+                                        else {
+                                            p_space.m_SPTQueue.insert(NodeDistPair(begin, dist));
+                                        }
+                                    }
+                                }
+                            }
+                            std::swap(p_curr, p_next);
+                        }
+
+                        while (!p_curr->empty()) {
+                            p_space.m_SPTQueue.insert(p_curr->pop());
+                        }
+                    }
+                    else {
+                        for (SizeType begin = node.childStart; begin < node.childEnd; begin++) {
+                            _mm_prefetch((const char*)(data[m_pTreeRoots[begin].centerid]), _MM_HINT_T0);
+                        }
+                        for (SizeType begin = node.childStart; begin < node.childEnd; begin++) {
+                            SizeType index = m_pTreeRoots[begin].centerid;
+                            p_space.m_SPTQueue.insert(NodeDistPair(begin, fComputeDistance(p_query.GetQuantizedTarget(), data[index], data.C())));
+                        }
+                    }
+                }
+            }
+
+            template <typename T>
+            void SearchTrees(const Dataset<T>& data, std::function<float(const T*, const T*, DimensionType)> fComputeDistance, COMMON::QueryResultSet<T> &p_query,
+                COMMON::WorkSpace &p_space, const int p_limits) const
+            {
+                while (!p_space.m_SPTQueue.empty())
+                {
+                    NodeDistPair bcell = p_space.m_SPTQueue.pop();
+                    const BKTNode& tnode = m_pTreeRoots[bcell.node];
+                    if (tnode.childStart < 0) {
+                        if (!p_space.CheckAndSet(tnode.centerid)) {
+                            p_space.m_iNumberOfCheckedLeaves++;
+                            p_space.m_NGQueue.insert(NodeDistPair(tnode.centerid, bcell.distance));
+                        }
+                        if (p_space.m_iNumberOfCheckedLeaves >= p_limits) break;
+                    }
+                    else {
+                        for (SizeType begin = tnode.childStart; begin < tnode.childEnd; begin++) {
+                            _mm_prefetch((const char*)(data[m_pTreeRoots[begin].centerid]), _MM_HINT_T0);
+                        }
+                        if (!p_space.CheckAndSet(tnode.centerid)) {
+                            p_space.m_NGQueue.insert(NodeDistPair(tnode.centerid, bcell.distance));
+                        }
+                        for (SizeType begin = tnode.childStart; begin < tnode.childEnd; begin++) {
+                            SizeType index = m_pTreeRoots[begin].centerid;
+                            p_space.m_SPTQueue.insert(NodeDistPair(begin, fComputeDistance(p_query.GetQuantizedTarget(), data[index], data.C())));
+                        } 
+                    }
+                }
+            }
+
+        private:
+            std::vector<SizeType> m_pTreeStart;
+            std::vector<BKTNode> m_pTreeRoots;
+            std::unordered_map<SizeType, SizeType> m_pSampleCenterMap;
+
+        public:
+            std::unique_ptr<std::shared_timed_mutex> m_lock;
+            int m_iTreeNumber, m_iBKTKmeansK, m_iBKTLeafSize, m_iSamples, m_bfs;
+            float m_fBalanceFactor;
+            std::shared_ptr<SPTAG::COMMON::IQuantizer> m_pQuantizer;
+        };
+    }
+}
+#endif

SPANN/AnnService/inc/Core/Common/DistanceUtils.h

@@ -0,0 +1,167 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_DISTANCEUTILS_H_
+#define _SPTAG_COMMON_DISTANCEUTILS_H_
+
+#include <functional>
+#include <iostream>
+
+#include "CommonUtils.h"
+#include "InstructionUtils.h"
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        template <typename T>
+        using DistanceCalcReturn = float(*)(const T*, const T*, DimensionType);
+        template<typename T>
+        inline DistanceCalcReturn<T> DistanceCalcSelector(SPTAG::DistCalcMethod p_method);
+
+        class DistanceUtils
+        {
+        public:
+            template <typename T>
+            static float ComputeL2Distance(const T* pX, const T* pY, DimensionType length)
+            {
+                const T* pEnd4 = pX + ((length >> 2) << 2);
+                const T* pEnd1 = pX + length;
+
+                float diff = 0;
+
+                while (pX < pEnd4) {
+                    float c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                    c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                    c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                    c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                }
+                while (pX < pEnd1) {
+                    float c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                }
+                return diff;
+            }
+
+            static float ComputeL2Distance_SSE(const std::int8_t* pX, const std::int8_t* pY, DimensionType length);
+            static float ComputeL2Distance_AVX(const std::int8_t* pX, const std::int8_t* pY, DimensionType length);
+            static float ComputeL2Distance_AVX512(const std::int8_t* pX, const std::int8_t* pY, DimensionType length);
+
+            static float ComputeL2Distance_SSE(const std::uint8_t* pX, const std::uint8_t* pY, DimensionType length);
+            static float ComputeL2Distance_AVX(const std::uint8_t* pX, const std::uint8_t* pY, DimensionType length);
+            static float ComputeL2Distance_AVX512(const std::uint8_t* pX, const std::uint8_t* pY, DimensionType length);
+
+            static float ComputeL2Distance_SSE(const std::int16_t* pX, const std::int16_t* pY, DimensionType length);
+            static float ComputeL2Distance_AVX(const std::int16_t* pX, const std::int16_t* pY, DimensionType length);
+            static float ComputeL2Distance_AVX512(const std::int16_t* pX, const std::int16_t* pY, DimensionType length);
+
+            static float ComputeL2Distance_SSE(const float* pX, const float* pY, DimensionType length);
+            static float ComputeL2Distance_AVX(const float* pX, const float* pY, DimensionType length);
+            static float ComputeL2Distance_AVX512(const float* pX, const float* pY, DimensionType length);
+
+            template <typename T>
+            static float ComputeCosineDistance(const T* pX, const T* pY, DimensionType length)
+            {
+                const T* pEnd4 = pX + ((length >> 2) << 2);
+                const T* pEnd1 = pX + length;
+
+                float diff = 0;
+
+                while (pX < pEnd4)
+                {
+                    float c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+                    c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+                    c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+                    c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+                }
+                while (pX < pEnd1) diff += ((float)(*pX++) * (float)(*pY++));
+                int base = Utils::GetBase<T>();
+                return base * base - diff;
+            }
+
+            static float ComputeCosineDistance_SSE(const std::int8_t* pX, const std::int8_t* pY, DimensionType length);
+            static float ComputeCosineDistance_AVX(const std::int8_t* pX, const std::int8_t* pY, DimensionType length);
+            static float ComputeCosineDistance_AVX512(const std::int8_t* pX, const std::int8_t* pY, DimensionType length);
+
+            static float ComputeCosineDistance_SSE(const std::uint8_t* pX, const std::uint8_t* pY, DimensionType length);
+            static float ComputeCosineDistance_AVX(const std::uint8_t* pX, const std::uint8_t* pY, DimensionType length);
+            static float ComputeCosineDistance_AVX512(const std::uint8_t* pX, const std::uint8_t* pY, DimensionType length);
+
+            static float ComputeCosineDistance_SSE(const std::int16_t* pX, const std::int16_t* pY, DimensionType length);
+            static float ComputeCosineDistance_AVX(const std::int16_t* pX, const std::int16_t* pY, DimensionType length);
+            static float ComputeCosineDistance_AVX512(const std::int16_t* pX, const std::int16_t* pY, DimensionType length);
+
+            static float ComputeCosineDistance_SSE(const float* pX, const float* pY, DimensionType length);
+            static float ComputeCosineDistance_AVX(const float* pX, const float* pY, DimensionType length);
+            static float ComputeCosineDistance_AVX512(const float* pX, const float* pY, DimensionType length);
+
+
+            template<typename T>
+            static inline float ComputeDistance(const T* p1, const T* p2, DimensionType length, SPTAG::DistCalcMethod distCalcMethod)
+            {
+                auto func = DistanceCalcSelector<T>(distCalcMethod);
+                return func(p1, p2, length);
+            }
+
+            static inline float ConvertCosineSimilarityToDistance(float cs)
+            {
+                // Cosine similarity is in [-1, 1], the higher the value, the closer are the two vectors. 
+                // However, the tree is built and searched based on "distance" between two vectors, that's >=0. The smaller the value, the closer are the two vectors.
+                // So we do a linear conversion from a cosine similarity to a distance value.
+                return 1 - cs; //[1, 3]
+            }
+
+            static inline float ConvertDistanceBackToCosineSimilarity(float d)
+            {
+                return 1 - d;
+            }
+        };
+        template<typename T>
+        inline DistanceCalcReturn<T> DistanceCalcSelector(SPTAG::DistCalcMethod p_method)
+        {
+            bool isSize4 = (sizeof(T) == 4);
+            switch (p_method)
+            {
+            case SPTAG::DistCalcMethod::InnerProduct:
+            case SPTAG::DistCalcMethod::Cosine:
+                if (InstructionSet::AVX512())
+                {
+                    return &(DistanceUtils::ComputeCosineDistance_AVX512);
+                }
+                else if (InstructionSet::AVX2() || (isSize4 && InstructionSet::AVX()))
+                {
+                    return &(DistanceUtils::ComputeCosineDistance_AVX);
+                }
+                else if (InstructionSet::SSE2() || (isSize4 && InstructionSet::SSE()))
+                {
+                    return &(DistanceUtils::ComputeCosineDistance_SSE);
+                }
+                else {
+                    return &(DistanceUtils::ComputeCosineDistance);
+                }
+
+            case SPTAG::DistCalcMethod::L2:
+                if (InstructionSet::AVX512())
+                {
+                    return &(DistanceUtils::ComputeL2Distance_AVX512);
+                }
+                else if (InstructionSet::AVX2() || (isSize4 && InstructionSet::AVX()))
+                {
+                    return &(DistanceUtils::ComputeL2Distance_AVX);
+                }
+                else if (InstructionSet::SSE2() || (isSize4 && InstructionSet::SSE()))
+                {
+                    return &(DistanceUtils::ComputeL2Distance_SSE);
+                }
+                else {
+                    return &(DistanceUtils::ComputeL2Distance);
+                }
+
+            default:
+                break;
+            }
+            return nullptr;
+        }
+    }
+}
+
+#endif // _SPTAG_COMMON_DISTANCEUTILS_H_

SPANN/AnnService/inc/Core/Common/FineGrainedLock.h

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_FINEGRAINEDLOCK_H_
+#define _SPTAG_COMMON_FINEGRAINEDLOCK_H_
+
+#include <shared_mutex>
+#include <vector>
+#include <mutex>
+#include <memory>
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        class FineGrainedLock {
+        public:
+            FineGrainedLock() {
+                m_locks.reset(new std::mutex[PoolSize + 1]);
+            }
+            ~FineGrainedLock() {}
+
+            std::mutex& operator[](SizeType idx) {
+                unsigned index = hash_func((unsigned)idx);
+                return m_locks[index];
+            }
+
+            const std::mutex& operator[](SizeType idx) const {
+                unsigned index = hash_func((unsigned)idx);
+                return m_locks[index];
+            }
+        private:
+            static const int PoolSize = 32767;
+            std::unique_ptr<std::mutex[]> m_locks;
+
+            inline unsigned hash_func(unsigned idx) const
+            {
+                return ((unsigned)(idx * 99991) + _rotl(idx, 2) + 101) & PoolSize;
+            }
+        };
+    }
+}
+
+#endif // _SPTAG_COMMON_FINEGRAINEDLOCK_H_

SPANN/AnnService/inc/Core/Common/Heap.h

@@ -0,0 +1,110 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_HEAP_H_
+#define _SPTAG_COMMON_HEAP_H_
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+
+        // priority queue
+        template <typename T>
+        class Heap {
+        public:
+            Heap() : heap(nullptr), length(0), count(0) {}
+
+            Heap(int size) { Resize(size); }
+
+            void Resize(int size)
+            {
+                length = size;
+                heap.reset(new T[length + 1]);  // heap uses 1-based indexing
+                count = 0;
+                lastlevel = int(pow(2.0, floor(log2((float)size))));
+            }
+            ~Heap() {}
+            inline int size() { return count; }
+            inline bool empty() { return count == 0; }
+            inline void clear(int size)
+            {
+                if (size > length) Resize(size);
+                count = 0;
+            }
+
+            inline T& Top() { if (count == 0) return heap[0]; else return heap[1]; }
+
+            // Insert a new element in the heap.
+            void insert(const T& value)
+            {
+                /* If heap is full, then return without adding this element. */
+                int loc;
+                if (count == length) {
+                    int maxi = lastlevel;
+                    for (int i = lastlevel + 1; i <= length; i++)
+                        if (heap[maxi] < heap[i]) maxi = i;
+                    if (value > heap[maxi]) return;
+                    loc = maxi;
+                }
+                else {
+                    loc = ++(count);   /* Remember 1-based indexing. */
+                }
+                /* Keep moving parents down until a place is found for this node. */
+                int par = (loc >> 1);                 /* Location of parent. */
+                while (par > 0 && value < heap[par]) {
+                    heap[loc] = heap[par];     /* Move parent down to loc. */
+                    loc = par;
+                    par >>= 1;
+                }
+                /* Insert the element at the determined location. */
+                heap[loc] = value;
+            }
+            // Returns the node of minimum value from the heap (top of the heap).
+            bool pop(T& value)
+            {
+                if (count == 0) return false;
+                /* Switch first node with last. */
+                value = heap[1];
+                std::swap(heap[1], heap[count]);
+                count--;
+                heapify();      /* Move new node 1 to right position. */
+                return true;  /* Return old last node. */
+            }
+            T& pop()
+            {
+                if (count == 0) return heap[0];
+                /* Switch first node with last. */
+                std::swap(heap[1], heap[count]);
+                count--;
+                heapify();      /* Move new node 1 to right position. */
+                return heap[count + 1];  /* Return old last node. */
+            }
+        private:
+            // Storage array for the heap.
+            // Type T must be comparable.
+            std::unique_ptr<T[]> heap;
+            int length;
+            int count; // Number of element in the heap
+            int lastlevel;
+            // Reorganizes the heap (a parent is smaller than its children) starting with a node.
+
+            void heapify()
+            {
+                int parent = 1, next = 2;
+                while (next < count) {
+                    if (heap[next] > heap[next + 1]) next++;
+                    if (heap[next] < heap[parent]) {
+                        std::swap(heap[parent], heap[next]);
+                        parent = next;
+                        next <<= 1;
+                    }
+                    else break;
+                }
+                if (next == count && heap[next] < heap[parent]) std::swap(heap[parent], heap[next]);
+            }
+        };
+    }
+}
+
+#endif // _SPTAG_COMMON_HEAP_H_

SPANN/AnnService/inc/Core/Common/IQuantizer.h

@@ -0,0 +1,68 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_QUANTIZER_H_
+#define _SPTAG_COMMON_QUANTIZER_H_
+
+#include "inc/Core/Common.h"
+#include <cstdint>
+#include "inc/Core/CommonDataStructure.h"
+#include "DistanceUtils.h"
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        class IQuantizer
+        {
+        public:
+            virtual float L2Distance(const std::uint8_t* pX, const std::uint8_t* pY) const = 0;
+
+            virtual float CosineDistance(const std::uint8_t* pX, const std::uint8_t* pY) const = 0;
+
+            template <typename T>
+            std::function<float(const T*, const T*, SizeType)> DistanceCalcSelector(SPTAG::DistCalcMethod p_method) const;
+
+            virtual void QuantizeVector(const void* vec, std::uint8_t* vecout, bool ADC = true) const = 0;
+
+            virtual SizeType QuantizeSize() const = 0;
+
+            virtual void ReconstructVector(const std::uint8_t* qvec, void* vecout) const = 0;
+
+            virtual SizeType ReconstructSize() const = 0;
+
+            virtual DimensionType ReconstructDim() const = 0;
+
+            virtual std::uint64_t BufferSize() const = 0;
+
+            virtual ErrorCode SaveQuantizer(std::shared_ptr<Helper::DiskIO> p_out) const = 0;
+
+            virtual ErrorCode LoadQuantizer(std::shared_ptr<Helper::DiskIO> p_in) = 0;
+
+            virtual ErrorCode LoadQuantizer(uint8_t* raw_bytes) = 0;
+
+            static std::shared_ptr<IQuantizer> LoadIQuantizer(std::shared_ptr<Helper::DiskIO> p_in);
+
+            static std::shared_ptr<IQuantizer> LoadIQuantizer(SPTAG::ByteArray bytes);
+
+            virtual bool GetEnableADC() const = 0;
+
+            virtual void SetEnableADC(bool enableADC) = 0;
+
+            virtual QuantizerType GetQuantizerType() const = 0;
+
+            virtual VectorValueType GetReconstructType() const = 0;
+
+            virtual DimensionType GetNumSubvectors() const = 0;
+
+            virtual int GetBase() const = 0;
+
+            virtual float* GetL2DistanceTables() = 0;
+
+            template<typename T>
+            T* GetCodebooks();
+        };
+    }
+}
+
+#endif // _SPTAG_COMMON_QUANTIZER_H_ 

SPANN/AnnService/inc/Core/Common/InstructionUtils.h

@@ -0,0 +1,59 @@
+#ifndef _SPTAG_COMMON_INSTRUCTIONUTILS_H_
+#define _SPTAG_COMMON_INSTRUCTIONUTILS_H_
+
+#include <string>
+#include <vector>
+#include <bitset>
+#include <array>
+
+#ifndef GPU
+
+#ifndef _MSC_VER
+#include <cpuid.h>
+#include <xmmintrin.h>
+#include <immintrin.h>
+
+void cpuid(int info[4], int InfoType);
+
+#else
+#include <intrin.h>
+#define cpuid(info, x)    __cpuidex(info, x, 0)
+#endif
+
+#endif
+
+namespace SPTAG {
+    namespace COMMON {
+
+        class InstructionSet
+        {
+            // forward declarations
+            class InstructionSet_Internal;
+
+        public:
+            // getters
+            static bool AVX(void);
+            static bool SSE(void);
+            static bool SSE2(void);
+            static bool AVX2(void);
+            static bool AVX512(void);
+            static void PrintInstructionSet(void);
+
+        private:
+            static const InstructionSet_Internal CPU_Rep;
+
+            class InstructionSet_Internal
+            {
+            public:
+                InstructionSet_Internal();
+                bool HW_SSE;
+                bool HW_SSE2;
+                bool HW_AVX;
+                bool HW_AVX2;
+                bool HW_AVX512;
+            };
+        };
+    }
+}
+
+#endif

SPANN/AnnService/inc/Core/Common/PQQuantizer.h

@@ -0,0 +1,362 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_PQQUANTIZER_H_
+#define _SPTAG_COMMON_PQQUANTIZER_H_
+
+#include "CommonUtils.h"
+#include "DistanceUtils.h"
+#include "IQuantizer.h"
+#include <iostream>
+#include <fstream>
+#include <limits>
+#include <memory>
+#include <cassert>
+#include <cstring>
+
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        template <typename T>
+        class PQQuantizer : public IQuantizer
+        {
+        public:
+            PQQuantizer();
+
+            PQQuantizer(DimensionType NumSubvectors, SizeType KsPerSubvector, DimensionType DimPerSubvector, bool EnableADC, std::unique_ptr<T[]>&& Codebooks);
+
+            ~PQQuantizer();
+
+            virtual float L2Distance(const std::uint8_t* pX, const std::uint8_t* pY) const;
+
+            virtual float CosineDistance(const std::uint8_t* pX, const std::uint8_t* pY) const;
+
+            virtual void QuantizeVector(const void* vec, std::uint8_t* vecout, bool ADC = true) const;
+            
+            virtual SizeType QuantizeSize() const;
+
+            void ReconstructVector(const std::uint8_t* qvec, void* vecout) const;
+
+            virtual SizeType ReconstructSize() const;
+
+            virtual DimensionType ReconstructDim() const;
+
+            virtual std::uint64_t BufferSize() const;
+
+            virtual ErrorCode SaveQuantizer(std::shared_ptr<Helper::DiskIO> p_out) const;
+
+            virtual ErrorCode LoadQuantizer(std::shared_ptr<Helper::DiskIO> p_in);
+
+            virtual ErrorCode LoadQuantizer(std::uint8_t* raw_bytes);
+
+            virtual DimensionType GetNumSubvectors() const;
+
+            virtual int GetBase() const;
+
+            SizeType GetKsPerSubvector() const;
+
+            SizeType GetBlockSize() const;
+
+            DimensionType GetDimPerSubvector() const;
+
+            virtual bool GetEnableADC() const;
+
+            virtual void SetEnableADC(bool enableADC);
+
+            VectorValueType GetReconstructType() const
+            {
+                return GetEnumValueType<T>();
+            }
+
+            QuantizerType GetQuantizerType() const {
+                return QuantizerType::PQQuantizer;
+            }
+
+            float* GetL2DistanceTables();
+
+            T* GetCodebooks();
+
+        protected:
+            DimensionType m_NumSubvectors;
+            SizeType m_KsPerSubvector;
+            DimensionType m_DimPerSubvector;
+            SizeType m_BlockSize;
+            bool m_EnableADC;
+
+            inline SizeType m_DistIndexCalc(SizeType i, SizeType j, SizeType k) const;
+            void InitializeDistanceTables();
+
+            std::unique_ptr<T[]> m_codebooks;
+            std::unique_ptr<const float[]> m_L2DistanceTables;
+        };
+
+        template <typename T>
+        PQQuantizer<T>::PQQuantizer() : m_NumSubvectors(0), m_KsPerSubvector(0), m_DimPerSubvector(0), m_BlockSize(0), m_EnableADC(false)
+        {
+        }
+
+        template <typename T>
+        PQQuantizer<T>::PQQuantizer(DimensionType NumSubvectors, SizeType KsPerSubvector, DimensionType DimPerSubvector, bool EnableADC, std::unique_ptr<T[]>&& Codebooks) : m_NumSubvectors(NumSubvectors), m_KsPerSubvector(KsPerSubvector), m_DimPerSubvector(DimPerSubvector), m_BlockSize(KsPerSubvector* KsPerSubvector), m_codebooks(std::move(Codebooks)), m_EnableADC(EnableADC)
+        {
+            InitializeDistanceTables();
+        }
+
+        template <typename T>
+        PQQuantizer<T>::~PQQuantizer()
+        {}
+
+        template <typename T>
+        float PQQuantizer<T>::L2Distance(const std::uint8_t* pX, const std::uint8_t* pY) const
+            // pX must be query distance table for ADC
+        {
+            float out = 0;
+            if (GetEnableADC()) {          
+                float* ptr = (float*)pX;
+                for (int i = 0; i < m_NumSubvectors; i++) {
+                    out += ptr[pY[i]];
+                    ptr += m_KsPerSubvector;
+                }
+            }
+            else {
+                for (int i = 0; i < m_NumSubvectors; i++) {
+                    out += m_L2DistanceTables[m_DistIndexCalc(i, pX[i], pY[i])];
+                }                
+            }
+            return out;
+        }
+
+        template <typename T>
+        float PQQuantizer<T>::CosineDistance(const std::uint8_t* pX, const std::uint8_t* pY) const
+            // pX must be query distance table for ADC
+        {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Quantizer does not support CosineDistance!\n");
+            return 0;
+        }
+
+        template <typename T>
+        void PQQuantizer<T>::QuantizeVector(const void* vec, std::uint8_t* vecout, bool ADC) const
+        {
+            if (ADC && GetEnableADC())
+            {
+                auto distCalc = DistanceCalcSelector<T>(DistCalcMethod::L2);
+                float* ADCtable = (float*) vecout;
+                T* subcodebooks = m_codebooks.get();
+                T* subvec = (T*)vec;
+                for (int i = 0; i < m_NumSubvectors; i++)
+                {
+                    for (int j = 0; j < m_KsPerSubvector; j++)
+                    {
+                        (*ADCtable) = distCalc(subvec, subcodebooks, m_DimPerSubvector);
+                        ADCtable++;
+                        subcodebooks += m_DimPerSubvector;
+                    }
+                    subvec += m_DimPerSubvector;
+                }
+            }
+            else 
+            {
+                auto distCalc = DistanceCalcSelector<T>(DistCalcMethod::L2);
+                T* subvec = (T*)vec;
+                T* subcodebooks = m_codebooks.get();
+                for (int i = 0; i < m_NumSubvectors; i++) {
+                    int bestIndex = -1;
+                    float minDist = std::numeric_limits<float>::infinity();
+
+                    for (int j = 0; j < m_KsPerSubvector; j++) {
+                        float dist = distCalc(subvec, subcodebooks, m_DimPerSubvector);
+                        if (dist < minDist) {
+                            bestIndex = j;
+                            minDist = dist;
+                        }
+                        subcodebooks += m_DimPerSubvector;
+                    }
+                    assert(bestIndex != -1);
+                    vecout[i] = (std::uint8_t)bestIndex;
+                    subvec += m_DimPerSubvector;
+                }
+            }           
+        }
+
+        template <typename T>
+        SizeType PQQuantizer<T>::QuantizeSize() const
+        {
+            if (GetEnableADC())
+            {
+                return sizeof(float) * m_NumSubvectors * m_KsPerSubvector;
+            }
+            else
+            {
+                return m_NumSubvectors;
+            }           
+        }
+
+        template <typename T>
+        void PQQuantizer<T>::ReconstructVector(const std::uint8_t* qvec, void* vecout) const
+        {
+            T* sub_vecout = (T*)vecout;
+            T* subcodebooks = m_codebooks.get();
+            for (int i = 0; i < m_NumSubvectors; i++) {
+                memcpy(sub_vecout, subcodebooks + qvec[i] * m_DimPerSubvector, sizeof(T) * m_DimPerSubvector);
+                sub_vecout += m_DimPerSubvector;
+                subcodebooks += m_KsPerSubvector * m_DimPerSubvector;
+            }
+        }
+
+        template <typename T>
+        SizeType PQQuantizer<T>::ReconstructSize() const
+        {       
+            return sizeof(T) * ReconstructDim();
+        }
+
+        template <typename T>
+        DimensionType PQQuantizer<T>::ReconstructDim() const
+        {
+            return m_DimPerSubvector * m_NumSubvectors;
+        }
+
+        template <typename T>
+        std::uint64_t PQQuantizer<T>::BufferSize() const
+        {
+            return sizeof(T) * m_NumSubvectors * m_KsPerSubvector * m_DimPerSubvector + 
+                sizeof(DimensionType) + sizeof(SizeType) + sizeof(DimensionType) + sizeof(VectorValueType) + sizeof(QuantizerType);
+        }
+
+        template <typename T>
+        ErrorCode PQQuantizer<T>::SaveQuantizer(std::shared_ptr<Helper::DiskIO> p_out) const
+        {
+            QuantizerType qtype = QuantizerType::PQQuantizer;
+            VectorValueType rtype = GetEnumValueType<T>();
+            IOBINARY(p_out, WriteBinary, sizeof(QuantizerType), (char*)&qtype);
+            IOBINARY(p_out, WriteBinary, sizeof(VectorValueType), (char*)&rtype);
+            IOBINARY(p_out, WriteBinary, sizeof(DimensionType), (char*)&m_NumSubvectors);
+            IOBINARY(p_out, WriteBinary, sizeof(SizeType), (char*)&m_KsPerSubvector);
+            IOBINARY(p_out, WriteBinary, sizeof(DimensionType), (char*)&m_DimPerSubvector);
+            IOBINARY(p_out, WriteBinary, sizeof(T) * m_NumSubvectors * m_KsPerSubvector * m_DimPerSubvector, (char*)m_codebooks.get());
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Saving quantizer: Subvectors:%d KsPerSubvector:%d DimPerSubvector:%d\n", m_NumSubvectors, m_KsPerSubvector, m_DimPerSubvector);
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode PQQuantizer<T>::LoadQuantizer(std::shared_ptr<Helper::DiskIO> p_in)
+        {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Loading Quantizer.\n");
+            IOBINARY(p_in, ReadBinary, sizeof(DimensionType), (char*)&m_NumSubvectors);
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "After read subvecs: %s.\n", std::to_string(m_NumSubvectors).c_str());
+            IOBINARY(p_in, ReadBinary, sizeof(SizeType), (char*)&m_KsPerSubvector);
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "After read ks: %s.\n", std::to_string(m_KsPerSubvector).c_str());
+            IOBINARY(p_in, ReadBinary, sizeof(DimensionType), (char*)&m_DimPerSubvector);
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "After read dim: %s.\n", std::to_string(m_DimPerSubvector).c_str());
+            m_codebooks = std::make_unique<T[]>(m_NumSubvectors * m_KsPerSubvector * m_DimPerSubvector);
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "sizeof(T): %s.\n", std::to_string(sizeof(T)).c_str());
+            IOBINARY(p_in, ReadBinary, sizeof(T) * m_NumSubvectors * m_KsPerSubvector * m_DimPerSubvector, (char*)m_codebooks.get());
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "After read codebooks.\n");
+
+            m_BlockSize = m_KsPerSubvector * m_KsPerSubvector;
+            InitializeDistanceTables();
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Loaded quantizer: Subvectors:%d KsPerSubvector:%d DimPerSubvector:%d\n", m_NumSubvectors, m_KsPerSubvector, m_DimPerSubvector);
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode PQQuantizer<T>::LoadQuantizer(std::uint8_t* raw_bytes)
+        {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Loading Quantizer.\n");
+            m_NumSubvectors = *(DimensionType*)raw_bytes;
+            raw_bytes += sizeof(DimensionType);
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "After read subvecs: %s.\n", std::to_string(m_NumSubvectors).c_str());
+            m_KsPerSubvector = *(SizeType*)raw_bytes;
+            raw_bytes += sizeof(SizeType);
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "After read ks: %s.\n", std::to_string(m_KsPerSubvector).c_str());
+            m_DimPerSubvector = *(DimensionType*)raw_bytes;
+            raw_bytes += sizeof(DimensionType);
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "After read dim: %s.\n", std::to_string(m_DimPerSubvector).c_str());
+            m_codebooks = std::make_unique<T[]>(m_NumSubvectors * m_KsPerSubvector * m_DimPerSubvector);
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "sizeof(T): %s.\n", std::to_string(sizeof(T)).c_str());
+            std::memcpy(m_codebooks.get(), raw_bytes, sizeof(T) * m_NumSubvectors * m_KsPerSubvector * m_DimPerSubvector);
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "After read codebooks.\n");
+
+            m_BlockSize = m_KsPerSubvector * m_KsPerSubvector;
+            InitializeDistanceTables();
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Loaded quantizer: Subvectors:%d KsPerSubvector:%d DimPerSubvector:%d\n", m_NumSubvectors, m_KsPerSubvector, m_DimPerSubvector);
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        int PQQuantizer<T>::GetBase() const
+        {
+            return COMMON::Utils::GetBase<T>();
+        }
+
+        template <typename T>
+        DimensionType PQQuantizer<T>::GetNumSubvectors() const
+        {
+            return m_NumSubvectors;
+        }
+
+        template <typename T>
+        SizeType PQQuantizer<T>::GetKsPerSubvector() const
+        {
+            return m_KsPerSubvector;
+        }
+
+        template <typename T>
+        SizeType PQQuantizer<T>::GetBlockSize() const
+        {
+            return m_BlockSize;
+        }
+
+        template <typename T>
+        DimensionType PQQuantizer<T>::GetDimPerSubvector() const
+        {
+            return m_DimPerSubvector;
+        }
+
+        template <typename T>
+        bool PQQuantizer<T>::GetEnableADC() const
+        {
+            return m_EnableADC;
+        }
+
+        template <typename T>
+        void PQQuantizer<T>::SetEnableADC(bool enableADC)
+        {
+            m_EnableADC = enableADC;
+        }
+
+        template <typename T>
+        inline SizeType PQQuantizer<T>::m_DistIndexCalc(SizeType i, SizeType j, SizeType k) const {
+            return m_BlockSize * i + j * m_KsPerSubvector + k;
+        }
+
+        template <typename T>
+        void PQQuantizer<T>::InitializeDistanceTables()
+        {
+            auto temp_m_L2DistanceTables = std::make_unique<float[]>(m_BlockSize * m_NumSubvectors);
+            auto L2Dist = DistanceCalcSelector<T>(DistCalcMethod::L2);
+
+            for (int i = 0; i < m_NumSubvectors; i++) {
+                SizeType baseIdx = i * m_KsPerSubvector * m_DimPerSubvector;
+                for (int j = 0; j < m_KsPerSubvector; j++) {
+                    for (int k = 0; k < m_KsPerSubvector; k++) {
+                        temp_m_L2DistanceTables[m_DistIndexCalc(i, j, k)] = L2Dist(&m_codebooks[baseIdx + j * m_DimPerSubvector], &m_codebooks[baseIdx + k * m_DimPerSubvector], m_DimPerSubvector);
+                    }
+                }
+            }
+            m_L2DistanceTables = std::move(temp_m_L2DistanceTables);
+        }
+
+        template <typename T>
+        float* PQQuantizer<T>::GetL2DistanceTables() {
+            return (float*)(m_L2DistanceTables.get());
+        }
+ 
+        template<typename T>
+        T* PQQuantizer<T>::GetCodebooks() {
+          return (T*)(m_codebooks.get());
+        }
+    }
+}
+
+#endif // _SPTAG_COMMON_PQQUANTIZER_H_

SPANN/AnnService/inc/Core/Common/QueryResultSet.h

@@ -0,0 +1,124 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_QUERYRESULTSET_H_
+#define _SPTAG_COMMON_QUERYRESULTSET_H_
+
+#include "inc/Core/SearchQuery.h"
+#include "DistanceUtils.h"
+#include <algorithm>
+#include "IQuantizer.h"
+
+namespace SPTAG
+{
+namespace COMMON
+{
+
+inline bool operator < (const BasicResult& lhs, const BasicResult& rhs)
+{
+    return ((lhs.Dist < rhs.Dist) || ((lhs.Dist == rhs.Dist) && (lhs.VID < rhs.VID)));
+}
+
+
+inline bool Compare(const BasicResult& lhs, const BasicResult& rhs)
+{
+    return ((lhs.Dist < rhs.Dist) || ((lhs.Dist == rhs.Dist) && (lhs.VID < rhs.VID)));
+}
+
+
+// Space to save temporary answer, similar with TopKCache
+template<typename T>
+class QueryResultSet : public QueryResult
+{
+public:
+    QueryResultSet(const T* _target, int _K) : QueryResult(_target, _K, false)
+    {
+    }
+
+    QueryResultSet(const QueryResultSet& other) : QueryResult(other)
+    {
+    }
+
+    ~QueryResultSet()
+    {
+    }
+
+    inline void SetTarget(const T* p_target, const std::shared_ptr<IQuantizer>& quantizer)
+    {
+        if (quantizer == nullptr) QueryResult::SetTarget((const void*)p_target);
+        else
+        {
+            if (m_target == m_quantizedTarget || (m_quantizedSize != quantizer->QuantizeSize()))
+            {
+                if (m_target != m_quantizedTarget) ALIGN_FREE(m_quantizedTarget);
+                m_quantizedTarget = ALIGN_ALLOC(quantizer->QuantizeSize());
+                m_quantizedSize = quantizer->QuantizeSize();
+            }
+            m_target = p_target;
+            quantizer->QuantizeVector((void*)p_target, (uint8_t*)m_quantizedTarget);
+        }
+    }
+
+    inline const T* GetTarget() const
+    {
+        return reinterpret_cast<const T*>(m_target);
+    }
+
+    T* GetQuantizedTarget()
+    {
+        return reinterpret_cast<T*>(m_quantizedTarget);
+    }
+
+    inline float worstDist() const
+    {
+        return m_results[0].Dist;
+    }
+
+    bool AddPoint(const SizeType index, float dist)
+    {
+        if (dist < m_results[0].Dist || (dist == m_results[0].Dist && index < m_results[0].VID))
+        {
+            m_results[0].VID = index;
+            m_results[0].Dist = dist;
+            Heapify(m_resultNum);
+            return true;
+        }
+        return false;
+    }
+
+    inline void SortResult()
+    {
+        for (int i = m_resultNum - 1; i >= 0; i--)
+        {
+            std::swap(m_results[0], m_results[i]);
+            Heapify(i);
+        }
+    }
+
+    void Reverse()
+    {
+        std::reverse(m_results.Data(), m_results.Data() + m_resultNum);
+    }
+
+private:
+    void Heapify(int count)
+    {
+        int parent = 0, next = 1, maxidx = count - 1;
+        while (next < maxidx)
+        {
+            if (m_results[next] < m_results[next + 1]) next++;
+            if (m_results[parent] < m_results[next])
+            {
+                std::swap(m_results[next], m_results[parent]);
+                parent = next;
+                next = (parent << 1) + 1;
+            }
+            else break;
+        }
+        if (next == maxidx && m_results[parent] < m_results[next]) std::swap(m_results[parent], m_results[next]);
+    }
+};
+}
+}
+
+#endif // _SPTAG_COMMON_QUERYRESULTSET_H_

SPANN/AnnService/inc/Core/Common/RelativeNeighborhoodGraph.h

@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_RNG_H_
+#define _SPTAG_COMMON_RNG_H_
+
+#include "NeighborhoodGraph.h"
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        class RelativeNeighborhoodGraph: public NeighborhoodGraph
+        {
+        public:
+            RelativeNeighborhoodGraph() { m_pNeighborhoodGraph.SetName("RNG"); }
+
+            void RebuildNeighbors(VectorIndex* index, const SizeType node, SizeType* nodes, const BasicResult* queryResults, const int numResults) {
+                DimensionType count = 0;
+                for (int j = 0; j < numResults && count < m_iNeighborhoodSize; j++) {
+                    const BasicResult& item = queryResults[j];
+                    if (item.VID < 0) break;
+                    if (item.VID == node) continue;
+
+                    bool good = true;
+                    for (DimensionType k = 0; k < count; k++) {
+                        if (m_fRNGFactor * index->ComputeDistance(index->GetSample(nodes[k]), index->GetSample(item.VID)) < item.Dist) {
+                            good = false;
+                            break;
+                        }
+                    }
+                    if (good) nodes[count++] = item.VID;
+                }
+                for (DimensionType j = count; j < m_iNeighborhoodSize; j++)  nodes[j] = -1;
+            }
+
+            void InsertNeighbors(VectorIndex* index, const SizeType node, SizeType insertNode, float insertDist)
+            {                
+                SizeType* nodes = m_pNeighborhoodGraph[node];
+                const void* nodeVec = index->GetSample(node);
+                const void* insertVec = index->GetSample(insertNode);
+                
+                std::lock_guard<std::mutex> lock(m_dataUpdateLock[node]);
+
+                _mm_prefetch((const char*)nodes, _MM_HINT_T0);
+                _mm_prefetch((const char*)(nodeVec), _MM_HINT_T0);
+                _mm_prefetch((const char*)(insertVec), _MM_HINT_T0);
+                for (DimensionType i = 0; i < m_iNeighborhoodSize; i++) {
+                    auto futureNode = nodes[i];
+                    if (futureNode < 0) break;
+                    _mm_prefetch((const char*)(index->GetSample(futureNode)), _MM_HINT_T0);
+                }
+
+                SizeType tmpNode;
+                float tmpDist;
+                const void* tmpVec;
+                int checkNeighborhoodSize = (nodes[m_iNeighborhoodSize - 1] < -1) ? m_iNeighborhoodSize - 1 : m_iNeighborhoodSize;
+                for (DimensionType k = 0; k < checkNeighborhoodSize; k++)
+                {
+                    tmpNode = nodes[k];
+                    if (tmpNode < 0) {
+                        nodes[k] = insertNode;
+                        break;
+                    }
+
+                    tmpVec = index->GetSample(tmpNode);
+                    tmpDist = index->ComputeDistance(tmpVec, nodeVec);
+                    if (tmpDist > insertDist || (insertDist == tmpDist && insertNode < tmpNode))
+                    {
+                        nodes[k] = insertNode;
+                        while (++k < checkNeighborhoodSize && index->ComputeDistance(tmpVec, nodeVec) <= index->ComputeDistance(tmpVec, insertVec)) {
+                            std::swap(tmpNode, nodes[k]);
+                            if (tmpNode < 0) return;
+                            tmpVec = index->GetSample(tmpNode);
+                        }
+                        break;
+                    }
+                    else if (index->ComputeDistance(tmpVec, insertVec) < insertDist) {
+                        break;
+                    }
+                }
+            }
+        };
+    }
+}
+#endif

SPANN/AnnService/inc/Core/Common/WorkSpace.h

@@ -0,0 +1,324 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_WORKSPACE_H_
+#define _SPTAG_COMMON_WORKSPACE_H_
+
+#include "inc/Core/SearchResult.h"
+#include "CommonUtils.h"
+#include "Heap.h"
+
+#include <stdarg.h>
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        template <typename WorkSpaceType>
+        class IWorkSpaceFactory
+        {
+        public:
+            virtual std::unique_ptr<WorkSpaceType> GetWorkSpace() = 0;
+            virtual void ReturnWorkSpace(std::unique_ptr<WorkSpaceType> ws) = 0;
+        };
+
+        template <typename WorkSpaceType>
+        class ThreadLocalWorkSpaceFactory : public IWorkSpaceFactory<WorkSpaceType>
+        {
+        public:
+            static thread_local std::unique_ptr<WorkSpaceType> m_workspace;
+
+            virtual std::unique_ptr< WorkSpaceType> GetWorkSpace() override
+            {
+                return std::move(m_workspace);
+            }
+
+            virtual void ReturnWorkSpace(std::unique_ptr<WorkSpaceType> ws) override
+            {
+                m_workspace = std::move(ws);
+            }
+
+        };
+
+        class OptHashPosVector
+        {
+        protected:
+            // Max loop number in one hash block.
+            static const int m_maxLoop = 8;
+
+            // Could we use the second hash block.
+            bool m_secondHash;
+
+            int m_exp;
+
+            // Max pool size.
+            int m_poolSize;
+
+            // Record 2 hash tables.
+            // [0~m_poolSize + 1) is the first block.
+            // [m_poolSize + 1, 2*(m_poolSize + 1)) is the second block;
+            std::unique_ptr<SizeType[]> m_hashTable;
+
+
+            inline unsigned hash_func2(unsigned idx, int poolSize, int loop)
+            {
+                return (idx + loop) & poolSize;
+            }
+
+
+            inline unsigned hash_func(unsigned idx, int poolSize)
+            {
+                return ((unsigned)(idx * 99991) + _rotl(idx, 2) + 101) & poolSize;
+            }
+
+        public:
+            OptHashPosVector(): m_secondHash(false), m_exp(2), m_poolSize(8191) {}
+
+            ~OptHashPosVector() {}
+
+
+            void Init(SizeType size, int exp)
+            {
+                int ex = 0;
+                while (size != 0) {
+                    ex++;
+                    size >>= 1;
+                }
+                m_secondHash = true;
+                m_exp = exp;
+                m_poolSize = (1 << (ex + exp)) - 1;
+                m_hashTable.reset(new SizeType[(m_poolSize + 1) * 2]);
+                clear();
+            }
+
+            void clear()
+            {
+                if (!m_secondHash)
+                {
+                    // Clear first block.
+                    memset(m_hashTable.get(), 0, sizeof(SizeType) * (m_poolSize + 1));
+                }
+                else
+                {
+                    // Clear all blocks.
+                    m_secondHash = false;
+                    memset(m_hashTable.get(), 0, 2 * sizeof(SizeType) * (m_poolSize + 1));
+                }
+            }
+
+            inline int HashTableExponent() const { return m_exp; }
+
+            inline int MaxCheck() const { return (1 << (int)(log2(m_poolSize + 1) - m_exp)); }
+
+            inline bool CheckAndSet(SizeType idx)
+            {
+                // Inner Index is begin from 1
+                return _CheckAndSet(m_hashTable.get(), m_poolSize, true, idx + 1) == 0;
+            }
+
+            inline void DoubleSize()
+            {
+                int new_poolSize = ((m_poolSize + 1) << 1) - 1; 
+                SizeType* new_hashTable = new SizeType[(new_poolSize + 1) * 2];
+                memset(new_hashTable, 0, sizeof(SizeType) * (new_poolSize + 1) * 2);
+
+                m_secondHash = false;
+                for (int i = 0; i <= new_poolSize; i++)
+                    if (m_hashTable[i]) _CheckAndSet(new_hashTable, new_poolSize, true, m_hashTable[i]);
+
+                m_exp++;
+                m_poolSize = new_poolSize;
+                m_hashTable.reset(new_hashTable);
+            }
+
+            inline int _CheckAndSet(SizeType* hashTable, int poolSize, bool isFirstTable, SizeType idx)
+            {
+                unsigned index = hash_func((unsigned)idx, poolSize);
+                for (int loop = 0; loop < m_maxLoop; ++loop)
+                {
+                    if (!hashTable[index])
+                    {
+                        // index first match and record it.
+                        hashTable[index] = idx;
+                        return 1;
+                    }
+                    if (hashTable[index] == idx)
+                    {
+                        // Hit this item in hash table.
+                        return 0;
+                    }
+                    // Get next hash position.
+                    index = hash_func2(index, poolSize, loop);
+                }
+
+                if (isFirstTable)
+                {
+                    // Use second hash block.
+                    m_secondHash = true;
+                    return _CheckAndSet(hashTable + poolSize + 1, poolSize, false, idx);
+                }
+
+                DoubleSize();
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Hash table is full! Set HashTableExponent to larger value (default is 2). NewHashTableExponent=%d NewPoolSize=%d\n", m_exp, m_poolSize);
+                return _CheckAndSet(m_hashTable.get(), m_poolSize, true, idx);
+            }
+        };
+
+        class DistPriorityQueue {
+            int m_size;
+            std::unique_ptr<float[]> m_data;
+            int m_length;
+            int m_count;
+            
+        public:
+            DistPriorityQueue(): m_size(0), m_length(0), m_count(0) {}
+
+            void Resize(int size_) {
+                m_size = size_;
+                m_data.reset(new float[size_ + 1]);
+                
+                m_data[1] = MaxDist;
+                m_length = 1;
+                m_count = size_;
+            }
+            void clear(int count_) {
+                if (count_ > m_size) {
+                    m_size = count_;
+                    m_data.reset(new float[count_ + 1]);
+                }
+                m_data[1] = MaxDist;
+                m_length = 1;
+                m_count = count_;
+                
+            }
+            bool insert(float dist) {
+                if (dist > m_data[1]) return false;
+
+                if (m_length == m_count) {
+                    m_data[1] = dist;
+                    int parent = 1, next = 2;
+                    while (next < m_length) {
+                        if (m_data[next] < m_data[next + 1]) next++;
+                        if (m_data[next] > m_data[parent]) {
+                            std::swap(m_data[parent], m_data[next]);
+                            parent = next;
+                            next <<= 1;
+                        }
+                        else break;
+                    }
+                    if (next == m_length && m_data[next] > m_data[parent]) std::swap(m_data[parent], m_data[next]);
+                }
+                else {
+                    int next = ++(m_length), parent = (next >> 1);
+                    while (parent > 0 && dist > m_data[parent]) {
+                        m_data[next] = m_data[parent];
+                        next = parent;
+                        parent >>= 1;
+                    }
+                    m_data[next] = dist;
+                }
+                return true;
+            }
+            inline float worst() {
+                return m_data[1];
+            }
+        };
+
+        class IWorkSpace {};
+
+        // Variables for each single NN search
+        struct WorkSpace : public IWorkSpace
+        {
+            WorkSpace() {}
+
+            WorkSpace(WorkSpace& other) 
+            {
+                Initialize(other.m_iMaxCheck, other.nodeCheckStatus.HashTableExponent());
+            }
+
+            ~WorkSpace() {
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Delete workspace happens!\n");
+            }
+
+            void Initialize(int maxCheck, int hashExp)
+            {
+                nodeCheckStatus.Init(maxCheck, hashExp);
+                m_SPTQueue.Resize(maxCheck * 10);
+                m_NGQueue.Resize(maxCheck * 30);
+                m_Results.Resize(maxCheck / 16);
+
+                m_iNumOfContinuousNoBetterPropagation = 0;
+                //m_iContinuousLimit = maxCheck / 64;
+                m_iNumberOfTreeCheckedLeaves = 0;
+                m_iNumberOfCheckedLeaves = 0;
+                m_iMaxCheck = maxCheck;
+                m_relaxedMono = false;
+            }
+
+            void Initialize(va_list& arg)
+            {
+                int maxCheck = va_arg(arg, int);
+                int hashExp = va_arg(arg, int);
+                Initialize(maxCheck, hashExp);
+            }
+
+            void Reset(int maxCheck, int resultNum)
+            {
+                nodeCheckStatus.clear();
+                m_SPTQueue.clear(maxCheck * 10);
+                m_NGQueue.clear(maxCheck * 30);
+                m_Results.clear(max(maxCheck / 16, resultNum));
+
+                m_iNumOfContinuousNoBetterPropagation = 0;
+                //m_iContinuousLimit = maxCheck / 64;
+                m_iNumberOfTreeCheckedLeaves = 0;
+                m_iNumberOfCheckedLeaves = 0;
+                m_iMaxCheck = maxCheck;
+                m_relaxedMono = false;
+            }
+
+            void ResetResult(int maxCheck, int resultNum)
+            {
+                m_Results.clear(max(maxCheck / 16, resultNum));
+                m_iNumOfContinuousNoBetterPropagation = 0;
+                m_iNumberOfTreeCheckedLeaves = 0;
+                m_iNumberOfCheckedLeaves = 0;
+            }
+
+            inline bool CheckAndSet(SizeType idx)
+            {
+                return nodeCheckStatus.CheckAndSet(idx);
+            }
+
+            inline int HashTableExponent() const 
+            { 
+                return nodeCheckStatus.HashTableExponent(); 
+            }
+
+            static void Reset() {}
+
+            OptHashPosVector nodeCheckStatus;
+
+            // counter for dynamic pivoting
+            int m_iNumOfContinuousNoBetterPropagation;
+            int m_iContinuousLimit;
+            int m_iNumberOfTreeCheckedLeaves;
+            int m_iNumberOfCheckedLeaves;
+            int m_iMaxCheck;
+            bool m_relaxedMono;
+
+            // Prioriy queue used for neighborhood graph
+            Heap<NodeDistPair> m_NGQueue;
+
+            // Priority queue Used for Tree
+            Heap<NodeDistPair> m_SPTQueue;
+            // Priority queue Used for Tree BFS
+            Heap<NodeDistPair> m_currBSPTQueue;
+            Heap<NodeDistPair> m_nextBSPTQueue;
+
+            DistPriorityQueue m_Results;
+        };
+    }
+}
+
+#endif // _SPTAG_COMMON_WORKSPACE_H_

SPANN/AnnService/inc/Core/CommonDataStructure.h

@@ -0,0 +1,226 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMONDATASTRUCTURE_H_
+#define _SPTAG_COMMONDATASTRUCTURE_H_
+
+#include "inc/Core/Common.h"
+
+namespace SPTAG
+{
+
+template<typename T>
+class Array
+{
+public:
+    Array();
+
+    Array(T* p_array, std::size_t p_length, bool p_transferOwnership);
+    
+    Array(T* p_array, std::size_t p_length, std::shared_ptr<T> p_dataHolder);
+
+    Array(Array<T>&& p_right);
+
+    Array(const Array<T>& p_right);
+
+    Array<T>& operator= (Array<T>&& p_right);
+
+    Array<T>& operator= (const Array<T>& p_right);
+
+    T& operator[] (std::size_t p_index);
+
+    const T& operator[] (std::size_t p_index) const;
+
+    ~Array();
+
+    T* Data() const;
+
+    std::size_t Length() const;
+
+    std::shared_ptr<T> DataHolder() const;
+    
+    void Set(T* p_array, std::size_t p_length, bool p_transferOwnership);
+
+    void Clear();
+
+    static Array<T> Alloc(std::size_t p_length);
+
+    const static Array<T> c_empty;
+
+private:
+    T* m_data;
+
+    std::size_t m_length;
+
+    // Notice this is holding an array. Set correct deleter for this.
+    std::shared_ptr<T> m_dataHolder;
+};
+
+template<typename T>
+const Array<T> Array<T>::c_empty;
+
+
+template<typename T>
+Array<T>::Array()
+    : m_data(nullptr),
+    m_length(0)
+{
+}
+
+template<typename T>
+Array<T>::Array(T* p_array, std::size_t p_length, bool p_transferOnwership)
+
+    : m_data(p_array),
+    m_length(p_length)
+{
+    if (p_transferOnwership)
+    {
+        m_dataHolder.reset(m_data, std::default_delete<T[]>());
+    }
+}
+
+
+template<typename T>
+Array<T>::Array(T* p_array, std::size_t p_length, std::shared_ptr<T> p_dataHolder)
+    : m_data(p_array),
+    m_length(p_length),
+    m_dataHolder(std::move(p_dataHolder))
+{
+}
+
+
+template<typename T>
+Array<T>::Array(Array<T>&& p_right)
+    : m_data(p_right.m_data),
+    m_length(p_right.m_length),
+    m_dataHolder(std::move(p_right.m_dataHolder))
+{
+}
+
+
+template<typename T>
+Array<T>::Array(const Array<T>& p_right)
+    : m_data(p_right.m_data),
+    m_length(p_right.m_length),
+    m_dataHolder(p_right.m_dataHolder)
+{
+}
+
+
+template<typename T>
+Array<T>&
+Array<T>::operator= (Array<T>&& p_right)
+{
+    m_data = p_right.m_data;
+    m_length = p_right.m_length;
+    m_dataHolder = std::move(p_right.m_dataHolder);
+
+    return *this;
+}
+
+
+template<typename T>
+Array<T>&
+Array<T>::operator= (const Array<T>& p_right)
+{
+    m_data = p_right.m_data;
+    m_length = p_right.m_length;
+    m_dataHolder = p_right.m_dataHolder;
+
+    return *this;
+}
+
+
+template<typename T>
+T&
+Array<T>::operator[] (std::size_t p_index)
+{
+    return m_data[p_index];
+}
+
+
+template<typename T>
+const T&
+Array<T>::operator[] (std::size_t p_index) const
+{
+    return m_data[p_index];
+}
+
+
+template<typename T>
+Array<T>::~Array()
+{
+}
+
+
+template<typename T>
+T*
+Array<T>::Data() const
+{
+    return m_data;
+}
+
+
+template<typename T>
+std::size_t
+Array<T>::Length() const
+{
+    return m_length;
+}
+
+
+template<typename T>
+std::shared_ptr<T>
+Array<T>::DataHolder() const
+{
+    return m_dataHolder;
+}
+
+
+template<typename T>
+void
+Array<T>::Set(T* p_array, std::size_t p_length, bool p_transferOwnership)
+{
+    m_data = p_array;
+    m_length = p_length;
+
+    if (p_transferOwnership)
+    {
+        m_dataHolder.reset(m_data, std::default_delete<T[]>());
+    }
+}
+
+
+template<typename T>
+void
+Array<T>::Clear()
+{
+    m_data = nullptr;
+    m_length = 0;
+    m_dataHolder.reset();
+}
+
+
+template<typename T>
+Array<T>
+Array<T>::Alloc(std::size_t p_length)
+{
+    Array<T> arr;
+    if (0 == p_length)
+    {
+        return arr;
+    }
+
+    arr.m_dataHolder.reset(new T[p_length], std::default_delete<T[]>());
+
+    arr.m_length = p_length;
+    arr.m_data = arr.m_dataHolder.get();
+    return arr;
+}
+
+
+typedef Array<std::uint8_t> ByteArray;
+
+} // namespace SPTAG
+
+#endif // _SPTAG_COMMONDATASTRUCTURE_H_

SPANN/AnnService/inc/Core/DefinitionList.h

@@ -0,0 +1,142 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifdef DefineVectorValueType
+
+DefineVectorValueType(Int8, std::int8_t)
+DefineVectorValueType(UInt8, std::uint8_t)
+DefineVectorValueType(Int16, std::int16_t)
+DefineVectorValueType(Float, float)
+
+#endif // DefineVectorValueType
+
+#ifdef DefineVectorValueType2
+
+DefineVectorValueType2(Int8, Int8, std::int8_t, std::int8_t)
+DefineVectorValueType2(Int8, UInt8, std::int8_t, std::uint8_t)
+DefineVectorValueType2(Int8, Int16, std::int8_t, std::int16_t)
+DefineVectorValueType2(Int8, Float, std::int8_t, float)
+DefineVectorValueType2(UInt8, Int8, std::uint8_t, std::int8_t)
+DefineVectorValueType2(UInt8, UInt8, std::uint8_t, std::uint8_t)
+DefineVectorValueType2(UInt8, Int16, std::uint8_t, std::int16_t)
+DefineVectorValueType2(UInt8, Float, std::uint8_t, float)
+DefineVectorValueType2(Int16, Int8, std::int16_t, std::int8_t)
+DefineVectorValueType2(Int16, UInt8, std::int16_t, std::uint8_t)
+DefineVectorValueType2(Int16, Int16, std::int16_t, std::int16_t)
+DefineVectorValueType2(Int16, Float, std::int16_t, float)
+DefineVectorValueType2(Float, Int8, float, std::int8_t)
+DefineVectorValueType2(Float, UInt8, float, std::uint8_t)
+DefineVectorValueType2(Float, Int16, float, std::int16_t)
+DefineVectorValueType2(Float, Float, float, float)
+
+#endif // DefineVectorValueType2
+
+#ifdef DefineDistCalcMethod
+
+DefineDistCalcMethod(L2)
+DefineDistCalcMethod(Cosine)
+DefineDistCalcMethod(InnerProduct)
+
+#endif // DefineDistCalcMethod
+
+#ifdef DefineQuantizerType
+
+DefineQuantizerType(None, std::shared_ptr<void>)
+DefineQuantizerType(PQQuantizer, std::shared_ptr<SPTAG::COMMON::PQQuantizer>)
+DefineQuantizerType(OPQQuantizer, std::shared_ptr<SPTAG::COMMON::OPQQuantizer>)
+
+#endif // DefineQuantizerType
+
+
+#ifdef DefineErrorCode
+
+// 0x0000 ~ 0x0FFF  General Status
+DefineErrorCode(Success, 0x0000)
+DefineErrorCode(Fail, 0x0001)
+DefineErrorCode(FailedOpenFile, 0x0002)
+DefineErrorCode(FailedCreateFile, 0x0003)
+DefineErrorCode(ParamNotFound, 0x0010)
+DefineErrorCode(FailedParseValue, 0x0011)
+DefineErrorCode(MemoryOverFlow, 0x0012)
+DefineErrorCode(LackOfInputs, 0x0013)
+DefineErrorCode(VectorNotFound, 0x0014)
+DefineErrorCode(EmptyIndex, 0x0015)
+DefineErrorCode(EmptyData, 0x0016)
+DefineErrorCode(DimensionSizeMismatch, 0x0017)
+DefineErrorCode(ExternalAbort, 0x0018)
+DefineErrorCode(EmptyDiskIO, 0x0019)
+DefineErrorCode(DiskIOFail, 0x0020)
+
+// 0x1000 ~ 0x1FFF  Index Build Status
+
+// 0x2000 ~ 0x2FFF  Index Serve Status
+
+// 0x3000 ~ 0x3FFF  Helper Function Status
+DefineErrorCode(ReadIni_FailedParseSection, 0x3000)
+DefineErrorCode(ReadIni_FailedParseParam, 0x3001)
+DefineErrorCode(ReadIni_DuplicatedSection, 0x3002)
+DefineErrorCode(ReadIni_DuplicatedParam, 0x3003)
+
+
+// 0x4000 ~ 0x4FFF Socket Library Status
+DefineErrorCode(Socket_FailedResolveEndPoint, 0x4000)
+DefineErrorCode(Socket_FailedConnectToEndPoint, 0x4001)
+
+
+#endif // DefineErrorCode
+
+
+
+#ifdef DefineIndexAlgo
+
+DefineIndexAlgo(BKT)
+DefineIndexAlgo(KDT)
+DefineIndexAlgo(SPANN)
+
+#endif // DefineIndexAlgo
+
+// target vectors and queries
+#ifdef DefineVectorFileType
+
+// number of vectors(int32_t), dimension(int32_t)
+// 1st vector
+// 2nd vector
+// ..
+DefineVectorFileType(DEFAULT)
+// dimension of 1st vector(int32_t), 1st vector
+// dimension of 2nd vector(int32_t), 2nd vector
+// ...
+DefineVectorFileType(XVEC)
+// vectors that have names and are viewable
+DefineVectorFileType(TXT)
+
+#endif // DefineVectorFileType
+
+#ifdef DefineTruthFileType
+
+// 1st nn id(int32_t), SPACE, 2nd nn id, SPACE, 3rd nn id,... 
+// 1st nn id, SPACE, 2nd nn id, SPACE, 3rd nn id,... 
+// ...
+DefineTruthFileType(TXT)
+// K of 1st vector(int32_t), 1st nn id(int32_t), SPACE, 2nd nn id, SPACE, 3rd nn id,... 
+// K of 2nd vector(int32_t), 1st nn id, SPACE, 2nd nn id, SPACE, 3rd nn id,... 
+// ...
+DefineTruthFileType(XVEC)
+// row(int32_t), column(int32_t), data...
+DefineTruthFileType(DEFAULT)
+
+#endif // DefineTruthFileType
+
+#ifdef DefineNumaStrategy
+
+DefineNumaStrategy(LOCAL)
+DefineNumaStrategy(SCATTER)
+
+#endif // DefineNumaStrategy
+
+#ifdef DefineOrderStrategy
+
+DefineOrderStrategy(ASC)
+DefineOrderStrategy(DESC)
+
+#endif // DefineOrderStrategy

SPANN/AnnService/inc/Core/MetadataSet.h

@@ -0,0 +1,136 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_METADATASET_H_
+#define _SPTAG_METADATASET_H_
+
+#include "CommonDataStructure.h"
+
+namespace SPTAG
+{
+
+class MetadataSet
+{
+public:
+    MetadataSet();
+
+    virtual ~MetadataSet();
+
+    virtual ByteArray GetMetadata(SizeType p_vectorID) const = 0;
+
+    virtual ByteArray GetMetadataCopy(SizeType p_vectorID) const = 0;
+
+    virtual SizeType Count() const = 0;
+
+    virtual bool Available() const = 0;
+
+    virtual std::pair<std::uint64_t, std::uint64_t> BufferSize() const = 0;
+
+    virtual void Add(const ByteArray& data) = 0;
+
+    virtual ErrorCode SaveMetadata(std::shared_ptr<Helper::DiskIO> p_metaOut, std::shared_ptr<Helper::DiskIO> p_metaIndexOut) = 0;
+
+    virtual ErrorCode SaveMetadata(const std::string& p_metaFile, const std::string& p_metaindexFile) = 0;
+ 
+    virtual void AddBatch(MetadataSet& data);
+    
+    virtual ErrorCode RefineMetadata(std::vector<SizeType>& indices, std::shared_ptr<MetadataSet>& p_newMetadata, std::uint64_t p_blockSize, std::uint64_t p_capacity, std::uint64_t p_metaSize) const;
+
+    virtual ErrorCode RefineMetadata(std::vector<SizeType>& indices, std::shared_ptr<Helper::DiskIO> p_metaOut, std::shared_ptr<Helper::DiskIO> p_metaIndexOut) const;
+
+    virtual ErrorCode RefineMetadata(std::vector<SizeType>& indices, const std::string& p_metaFile, const std::string& p_metaindexFile) const;
+
+    static bool GetMetadataOffsets(const std::uint8_t* p_meta, const std::uint64_t p_metaLength, std::uint64_t* p_offsets, std::uint64_t p_offsetLength, char p_delimiter = '\n');
+};
+
+
+class FileMetadataSet : public MetadataSet
+{
+public:
+    FileMetadataSet(const std::string& p_metaFile, const std::string& p_metaindexFile, 
+        std::uint64_t p_blockSize = 1024 * 1024, std::uint64_t p_capacity = MaxSize, std::uint64_t p_metaSize = 10);
+    
+    ~FileMetadataSet();
+
+    ByteArray GetMetadata(SizeType p_vectorID) const;
+
+    ByteArray GetMetadataCopy(SizeType p_vectorID) const;
+
+    SizeType Count() const;
+
+    bool Available() const;
+
+    std::pair<std::uint64_t, std::uint64_t> BufferSize() const;
+    
+    void Add(const ByteArray& data);
+
+    ErrorCode SaveMetadata(std::shared_ptr<Helper::DiskIO> p_metaOut, std::shared_ptr<Helper::DiskIO> p_metaIndexOut);
+
+    ErrorCode SaveMetadata(const std::string& p_metaFile, const std::string& p_metaindexFile);
+
+private:
+    std::shared_ptr<void> m_lock;
+
+    std::vector<std::uint64_t> m_offsets;
+
+    SizeType m_count;
+
+    std::shared_ptr<Helper::DiskIO> m_fp = nullptr;
+    
+    std::vector<std::uint8_t> m_newdata;
+};
+
+
+class MemMetadataSet : public MetadataSet
+{
+public:
+    MemMetadataSet(std::uint64_t p_blockSize, std::uint64_t p_capacity, std::uint64_t p_metaSize);
+
+    MemMetadataSet(ByteArray p_metadata, ByteArray p_offsets, SizeType p_count);
+
+    MemMetadataSet(ByteArray p_metadata, ByteArray p_offsets, SizeType p_count, 
+        std::uint64_t p_blockSize, std::uint64_t p_capacity, std::uint64_t p_metaSize);
+
+    MemMetadataSet(const std::string& p_metafile, const std::string& p_metaindexfile, 
+        std::uint64_t p_blockSize, std::uint64_t p_capacity, std::uint64_t p_metaSize);
+
+    MemMetadataSet(std::shared_ptr<Helper::DiskIO> p_metain, std::shared_ptr<Helper::DiskIO> p_metaindexin, 
+        std::uint64_t p_blockSize, std::uint64_t p_capacity, std::uint64_t p_metaSize);
+
+    ~MemMetadataSet();
+
+    ByteArray GetMetadata(SizeType p_vectorID) const;
+    
+    ByteArray GetMetadataCopy(SizeType p_vectorID) const;
+
+    SizeType Count() const;
+
+    bool Available() const;
+
+    std::pair<std::uint64_t, std::uint64_t> BufferSize() const;
+
+    void Add(const ByteArray& data);
+
+    ErrorCode SaveMetadata(std::shared_ptr<Helper::DiskIO> p_metaOut, std::shared_ptr<Helper::DiskIO> p_metaIndexOut);
+
+    ErrorCode SaveMetadata(const std::string& p_metaFile, const std::string& p_metaindexFile);
+
+private:
+    ErrorCode Init(std::shared_ptr<Helper::DiskIO> p_metain, std::shared_ptr<Helper::DiskIO> p_metaindexin,
+        std::uint64_t p_blockSize, std::uint64_t p_capacity, std::uint64_t p_metaSize);
+
+    std::shared_ptr<void> m_lock;
+
+    std::shared_ptr<void> m_pOffsets;
+
+    SizeType m_count;
+
+    ByteArray m_metadataHolder;
+
+    std::vector<std::uint8_t> m_newdata;
+};
+
+
+} // namespace SPTAG
+
+#endif // _SPTAG_METADATASET_H_

SPANN/AnnService/inc/Core/MultiIndexScan.h

@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_MULTI_INDEX_SCAN_H
+#define _SPTAG_MULTI_INDEX_SCAN_H
+
+#include <memory>
+
+#include <vector>
+#include <utility>
+#include <unordered_set>
+#include <queue>
+#include <stack>
+#include <chrono>
+
+#include "ResultIterator.h"
+#include "VectorIndex.h"
+#include <numeric>
+namespace SPTAG
+{
+    class MultiIndexScan
+    {
+    public:
+        MultiIndexScan();
+        MultiIndexScan(std::vector<std::shared_ptr<VectorIndex>> vecIndices,
+                       std::vector<void*> p_targets,
+                       unsigned int k,
+                       float (*rankFunction)(std::vector<float>),
+                       bool useTimer,
+                       int termCondVal,
+                       int searchLimit
+                       );
+        ~MultiIndexScan();
+        void Init(std::vector<std::shared_ptr<VectorIndex>> vecIndices,
+            std::vector<ByteArray> p_targets,
+            std::vector<float> weight,
+            unsigned int k,
+            bool useTimer,
+            int termCondVal,
+            int searchLimit);
+        bool Next(BasicResult& result);
+        void Close();
+
+    private:
+        std::vector<std::shared_ptr<ResultIterator>> indexIters;
+        std::vector<std::shared_ptr<VectorIndex>> fwdLUTs;
+        std::unordered_set<SizeType> seenSet;
+        std::vector<SPTAG::ByteArray> p_data_array;
+        std::vector<float> weight;
+
+        unsigned int k;
+
+
+        
+        bool useTimer;
+        unsigned int termCondVal;
+        int searchLimit;
+        std::chrono::time_point<std::chrono::high_resolution_clock> t_start;
+        
+        float (*func)(std::vector<float>);
+        
+        unsigned int consecutive_drops;
+        
+        bool terminate;
+        using pq_item = std::pair<float, SizeType>;
+        class pq_item_compare
+        {
+        public:
+            bool operator()(const pq_item& lhs, const pq_item& rhs)
+            {
+                return lhs.first < rhs.first;
+            }
+        };
+        std::priority_queue<pq_item, std::vector<pq_item>, pq_item_compare> pq;
+        std::stack<pq_item> outputStk;
+        float WeightedRankFunc(std::vector<float>);
+        
+    };
+} // namespace SPTAG
+#endif

SPANN/AnnService/inc/Core/SearchQuery.h

@@ -0,0 +1,257 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SEARCHQUERY_H_
+#define _SPTAG_SEARCHQUERY_H_
+
+#include "SearchResult.h"
+
+#include <cstring>
+
+namespace SPTAG
+{
+
+// Space to save temporary answer, similar with TopKCache
+class QueryResult
+{
+public:
+    typedef BasicResult* iterator;
+    typedef const BasicResult* const_iterator;
+
+    QueryResult()
+        : m_target(nullptr),
+          m_resultNum(0),
+          m_withMeta(false),
+          m_quantizedTarget(nullptr),
+          m_quantizedSize(0)
+    {
+    }
+
+    QueryResult(int p_resultNum)
+    {
+        Init(nullptr, p_resultNum, true);
+    }
+
+    QueryResult(const void* p_target, int p_resultNum, bool p_withMeta)
+    {
+        Init(p_target, p_resultNum, p_withMeta);
+    }
+
+    
+    QueryResult(const void* p_target, int p_resultNum, bool p_withMeta, BasicResult* p_results)
+        : m_target(p_target),
+          m_resultNum(p_resultNum),
+          m_withMeta(p_withMeta),
+          m_quantizedTarget((void*)p_target),
+          m_quantizedSize(0)
+    {
+        m_results.Set(p_results, p_resultNum, false);
+    }
+
+
+    QueryResult(const QueryResult& p_other)
+    {
+        Init(p_other.m_target, p_other.m_resultNum, p_other.m_withMeta);
+        if (m_resultNum > 0)
+        {
+            std::copy(p_other.m_results.Data(), p_other.m_results.Data() + m_resultNum, m_results.Data());
+        }
+        if (p_other.m_target != p_other.m_quantizedTarget)
+        {
+            m_quantizedSize = p_other.m_quantizedSize;
+            m_quantizedTarget = ALIGN_ALLOC(m_quantizedSize);
+            std::copy(reinterpret_cast<std::uint8_t*>(p_other.m_quantizedTarget), reinterpret_cast<std::uint8_t*>(p_other.m_quantizedTarget) + m_quantizedSize, reinterpret_cast<std::uint8_t*>(m_quantizedTarget));
+        }
+    }
+
+
+    QueryResult& operator=(const QueryResult& p_other)
+    {
+        if (m_target != m_quantizedTarget) ALIGN_FREE(m_quantizedTarget);
+
+        Init(p_other.m_target, p_other.m_resultNum, p_other.m_withMeta);
+        if (m_resultNum > 0)
+        {
+            std::copy(p_other.m_results.Data(), p_other.m_results.Data() + m_resultNum, m_results.Data());
+        }
+        if (p_other.m_target != p_other.m_quantizedTarget)
+        {
+            m_quantizedSize = p_other.m_quantizedSize;
+            m_quantizedTarget = ALIGN_ALLOC(m_quantizedSize);
+            std::copy(reinterpret_cast<std::uint8_t*>(p_other.m_quantizedTarget), reinterpret_cast<std::uint8_t*>(p_other.m_quantizedTarget) + m_quantizedSize, reinterpret_cast<std::uint8_t*>(m_quantizedTarget));
+        }
+        return *this;
+    }
+
+
+    ~QueryResult()
+    {
+        if (m_target != m_quantizedTarget)
+        {
+            ALIGN_FREE(m_quantizedTarget);
+        }
+    }
+
+
+    inline void Init(const void* p_target, int p_resultNum, bool p_withMeta)
+    {
+        m_target = p_target;
+        m_resultNum = p_resultNum;
+        m_withMeta = p_withMeta;
+        m_quantizedTarget = (void*)p_target;
+        m_quantizedSize = 0;
+
+        m_results = Array<BasicResult>::Alloc(p_resultNum);
+    }
+
+
+    inline int GetResultNum() const
+    {
+        return m_resultNum;
+    }
+
+
+    inline void SetResultNum(int p_resultNum)
+    {
+        m_resultNum = p_resultNum;
+    }
+
+
+    inline const void* GetTarget()
+    {
+        return m_target;
+    }
+
+
+    inline const void* GetQuantizedTarget()
+    {
+        return m_quantizedTarget;
+    }
+
+
+    inline void SetTarget(const void* p_target)
+    {
+        if (m_target != m_quantizedTarget)
+        {
+            ALIGN_FREE(m_quantizedTarget);
+        }
+        m_target = p_target;
+        m_quantizedTarget = (void*)p_target;
+        m_quantizedSize = 0;
+    }
+    
+
+    inline bool HasQuantizedTarget()
+    {
+        return m_target != m_quantizedTarget;
+    }
+
+
+    inline void CleanQuantizedTarget()
+    {
+        if (m_target != m_quantizedTarget) {
+            ALIGN_FREE(m_quantizedTarget);
+            m_quantizedTarget = (void*)m_target;
+        }
+    }
+
+
+    inline BasicResult* GetResult(int i) const
+    {
+        return i < m_resultNum ? m_results.Data() + i : nullptr;
+    }
+
+
+    inline void SetResult(int p_index, SizeType p_VID, float p_dist)
+    {
+        if (p_index < m_resultNum)
+        {
+            m_results[p_index].VID = p_VID;
+            m_results[p_index].Dist = p_dist;
+        }
+    }
+
+
+    inline BasicResult* GetResults() const
+    {
+        return m_results.Data();
+    }
+
+
+    inline bool WithMeta() const
+    {
+        return m_withMeta;
+    }
+
+
+    inline const ByteArray& GetMetadata(int p_index) const
+    {
+        if (p_index < m_resultNum && m_withMeta)
+        {
+            return m_results[p_index].Meta;
+        }
+
+        return ByteArray::c_empty;
+    }
+
+
+    inline void SetMetadata(int p_index, ByteArray p_metadata)
+    {
+        if (p_index < m_resultNum && m_withMeta)
+        {
+            m_results[p_index].Meta = std::move(p_metadata);
+        }
+    }
+
+
+    inline void Reset()
+    {
+        for (int i = 0; i < m_resultNum; i++)
+        {
+            m_results[i].VID = -1;
+            m_results[i].Dist = MaxDist;
+            m_results[i].Meta.Clear();
+        }
+    }
+
+
+    iterator begin()
+    {
+        return m_results.Data();
+    }
+
+
+    iterator end()
+    {
+        return m_results.Data() + m_resultNum;
+    }
+
+
+    const_iterator begin() const
+    {
+        return m_results.Data();
+    }
+
+
+    const_iterator end() const
+    {
+        return m_results.Data() + m_resultNum;
+    }
+
+
+protected:
+    const void* m_target;
+
+    void* m_quantizedTarget;
+
+    SizeType m_quantizedSize;
+
+    int m_resultNum;
+
+    bool m_withMeta;
+
+    Array<BasicResult> m_results;
+};
+} // namespace SPTAG
+
+#endif // _SPTAG_SEARCHQUERY_H_

SPANN/AnnService/inc/Core/SearchResult.h

@@ -0,0 +1,82 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SEARCHRESULT_H_
+#define _SPTAG_SEARCHRESULT_H_
+
+#include "CommonDataStructure.h"
+
+namespace SPTAG
+{
+    struct NodeDistPair
+    {
+        SizeType node;
+        float distance;
+
+        NodeDistPair(SizeType _node = -1, float _distance = MaxDist) : node(_node), distance(_distance) {}
+
+        inline bool operator < (const NodeDistPair& rhs) const
+        {
+            return distance < rhs.distance;
+        }
+
+        inline bool operator > (const NodeDistPair& rhs) const
+        {
+            return distance > rhs.distance;
+        }
+    };
+
+    struct Edge
+    {
+        SizeType node;
+        float distance;
+        SizeType tonode;
+        Edge() : node(MaxSize), distance(MaxDist), tonode(MaxSize) {}
+    };
+
+    struct EdgeCompare
+    {
+        inline bool operator()(const Edge& a, int b) const
+        {
+            return a.node < b;
+        };
+
+        inline bool operator()(int a, const Edge& b) const
+        {
+            return a < b.node;
+        };
+
+        inline bool operator()(const Edge& a, const Edge& b) const
+        {
+            if (a.node == b.node)
+            {
+                if (a.distance == b.distance)
+                {
+                    return a.tonode < b.tonode;
+                }
+
+                return a.distance < b.distance;
+            }
+
+            return a.node < b.node;
+        };
+    };
+
+    struct BasicResult
+    {
+        SizeType VID;
+        float Dist;
+        ByteArray Meta;
+        bool RelaxedMono;
+
+        BasicResult() : VID(-1), Dist(MaxDist), RelaxedMono(false) {}
+
+        BasicResult(SizeType p_vid, float p_dist) : VID(p_vid), Dist(p_dist), RelaxedMono(false) {}
+
+        BasicResult(SizeType p_vid, float p_dist, ByteArray p_meta) : VID(p_vid), Dist(p_dist), Meta(p_meta), RelaxedMono(false) {}
+        BasicResult(SizeType p_vid, float p_dist, ByteArray p_meta, bool p_relaxedMono) : VID(p_vid), Dist(p_dist), Meta(p_meta), RelaxedMono(p_relaxedMono) {}
+    };
+
+} // namespace SPTAG
+
+#endif // _SPTAG_SEARCHRESULT_H_

SPANN/AnnService/inc/Core/VectorSet.h

@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_VECTORSET_H_
+#define _SPTAG_VECTORSET_H_
+
+#include "CommonDataStructure.h"
+
+namespace SPTAG
+{
+
+class VectorSet
+{
+public:
+    VectorSet();
+
+    virtual ~VectorSet();
+
+    virtual VectorValueType GetValueType() const = 0;
+
+    virtual void* GetVector(SizeType p_vectorID) const = 0;
+
+    virtual void* GetData() const = 0;
+
+    virtual DimensionType Dimension() const = 0;
+
+    virtual SizeType Count() const = 0;
+
+    virtual bool Available() const = 0;
+
+    virtual ErrorCode Save(const std::string& p_vectorFile) const = 0;
+
+    virtual ErrorCode AppendSave(const std::string& p_vectorFile) const = 0;
+
+    virtual SizeType PerVectorDataSize() const = 0;
+
+    virtual void Normalize(int p_threads) = 0;
+};
+
+
+class BasicVectorSet : public VectorSet
+{
+public:
+    BasicVectorSet(const ByteArray& p_bytesArray,
+                   VectorValueType p_valueType,
+                   DimensionType p_dimension,
+                   SizeType p_vectorCount);
+
+    virtual ~BasicVectorSet();
+
+    virtual VectorValueType GetValueType() const;
+
+    virtual void* GetVector(SizeType p_vectorID) const;
+
+    virtual void* GetData() const;
+
+    virtual DimensionType Dimension() const;
+
+    virtual SizeType Count() const;
+
+    virtual bool Available() const;
+
+    virtual ErrorCode Save(const std::string& p_vectorFile) const;
+
+    virtual ErrorCode AppendSave(const std::string& p_vectorFile) const;
+
+    virtual SizeType PerVectorDataSize() const;
+
+    virtual void Normalize(int p_threads);
+
+private:
+    ByteArray m_data;
+
+    VectorValueType m_valueType;
+
+    DimensionType m_dimension;
+
+    SizeType m_vectorCount;
+
+    size_t m_perVectorDataSize;
+};
+
+} // namespace SPTAG
+
+#endif // _SPTAG_VECTORSET_H_

SPANN/AnnService/src/Aggregator/AggregatorContext.cpp

@@ -0,0 +1,117 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Aggregator/AggregatorContext.h"
+#include "inc/Helper/SimpleIniReader.h"
+
+#include <fstream>
+
+using namespace SPTAG;
+using namespace SPTAG::Aggregator;
+
+RemoteMachine::RemoteMachine()
+    : m_connectionID(Socket::c_invalidConnectionID),
+      m_status(RemoteMachineStatus::Disconnected)
+{
+}
+
+
+AggregatorContext::AggregatorContext(const std::string& p_filePath)
+    : m_initialized(false)
+{
+    Helper::IniReader iniReader;
+    if (ErrorCode::Success != iniReader.LoadIniFile(p_filePath))
+    {
+        return;
+    }
+
+    m_settings.reset(new AggregatorSettings);
+
+    m_settings->m_listenAddr = iniReader.GetParameter("Service", "ListenAddr", std::string("0.0.0.0"));
+    m_settings->m_listenPort = iniReader.GetParameter("Service", "ListenPort", std::string("8100"));
+    m_settings->m_threadNum = iniReader.GetParameter("Service", "ThreadNumber", static_cast<std::uint32_t>(8));
+    m_settings->m_socketThreadNum = iniReader.GetParameter("Service", "SocketThreadNumber", static_cast<std::uint32_t>(8));
+    m_settings->m_centers = iniReader.GetParameter("Service", "Centers", std::string("centers"));
+    m_settings->m_valueType = iniReader.GetParameter("Service", "ValueType", VectorValueType::Float);
+    m_settings->m_topK = iniReader.GetParameter("Service", "TopK", static_cast<SizeType>(-1));
+    m_settings->m_distMethod = iniReader.GetParameter("Service", "DistCalcMethod", DistCalcMethod::L2);
+    const std::string emptyStr;
+
+    SizeType serverNum = iniReader.GetParameter("Servers", "Number", static_cast<SizeType>(0));
+
+    for (SizeType i = 0; i < serverNum; ++i)
+    {
+        std::string sectionName("Server_");
+        sectionName += std::to_string(i);
+        if (!iniReader.DoesSectionExist(sectionName))
+        {
+            continue;
+        }
+
+        std::shared_ptr<RemoteMachine> remoteMachine(new RemoteMachine);
+
+        remoteMachine->m_address = iniReader.GetParameter(sectionName, "Address", emptyStr);
+        remoteMachine->m_port = iniReader.GetParameter(sectionName, "Port", emptyStr);
+
+        if (remoteMachine->m_address.empty() || remoteMachine->m_port.empty())
+        {
+            continue;
+        }
+
+        m_remoteServers.push_back(std::move(remoteMachine));
+    }
+
+    if (m_settings->m_topK > 0) {
+        std::ifstream inputStream(m_settings->m_centers, std::ifstream::binary);
+        if (!inputStream.is_open()) {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read file %s.\n", m_settings->m_centers.c_str());
+            exit(1);
+        }
+
+        SizeType row;
+        DimensionType col;
+        inputStream.read((char*)&row, sizeof(SizeType));
+        inputStream.read((char*)&col, sizeof(DimensionType));
+        if (row > serverNum) row = serverNum;
+        std::uint64_t totalRecordVectorBytes = ((std::uint64_t)GetValueTypeSize(m_settings->m_valueType)) * row * col;
+        ByteArray vectorSet = ByteArray::Alloc(totalRecordVectorBytes);
+        char* vecBuf = reinterpret_cast<char*>(vectorSet.Data());
+        inputStream.read(vecBuf, totalRecordVectorBytes);
+        inputStream.close();
+
+        m_centers.reset(new BasicVectorSet(vectorSet, m_settings->m_valueType, col, row));
+    }
+    m_initialized = true;
+}
+
+
+AggregatorContext::~AggregatorContext()
+{
+}
+
+
+bool
+AggregatorContext::IsInitialized() const
+{
+    return m_initialized;
+}
+
+
+const std::vector<std::shared_ptr<RemoteMachine>>&
+AggregatorContext::GetRemoteServers() const
+{
+    return m_remoteServers;
+}
+
+
+const std::shared_ptr<AggregatorSettings>&
+AggregatorContext::GetSettings() const
+{
+    return m_settings;
+}
+
+const std::shared_ptr<VectorSet>&
+AggregatorContext::GetCenters() const
+{
+    return m_centers;
+}

SPANN/AnnService/src/Aggregator/AggregatorExecutionContext.cpp

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Aggregator/AggregatorExecutionContext.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Aggregator;
+
+AggregatorExecutionContext::AggregatorExecutionContext(std::size_t p_totalServerNumber,
+                                                       Socket::PacketHeader p_requestHeader)
+    : m_requestHeader(std::move(p_requestHeader))
+{
+    m_results.clear();
+    m_results.resize(p_totalServerNumber);
+
+    m_unfinishedCount = static_cast<std::uint32_t>(p_totalServerNumber);
+}
+
+
+AggregatorExecutionContext::~AggregatorExecutionContext()
+{
+}
+
+
+std::size_t
+AggregatorExecutionContext::GetServerNumber() const
+{
+    return m_results.size();
+}
+
+
+AggregatorResult&
+AggregatorExecutionContext::GetResult(std::size_t p_num)
+{
+    return m_results[p_num];
+}
+
+
+const Socket::PacketHeader&
+AggregatorExecutionContext::GetRequestHeader() const
+{
+    return m_requestHeader;
+}
+
+
+bool
+AggregatorExecutionContext::IsCompletedAfterFinsh(std::uint32_t p_finishedCount)
+{
+    auto lastCount = m_unfinishedCount.fetch_sub(p_finishedCount);
+    return lastCount <= p_finishedCount;
+}

SPANN/AnnService/src/Aggregator/AggregatorService.cpp

@@ -0,0 +1,413 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Aggregator/AggregatorService.h"
+#include "inc/Server/QueryParser.h"
+#include "inc/Core/Common/DistanceUtils.h"
+#include "inc/Helper/Base64Encode.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Aggregator;
+
+AggregatorService::AggregatorService()
+    : m_shutdownSignals(m_ioContext),
+      m_pendingConnectServersTimer(m_ioContext)
+{
+}
+
+
+AggregatorService::~AggregatorService()
+{
+}
+
+
+bool
+AggregatorService::Initialize()
+{
+    std::string configFilePath = "Aggregator.ini";
+    m_aggregatorContext.reset(new AggregatorContext(configFilePath));
+
+    m_initalized = m_aggregatorContext->IsInitialized();
+
+    return m_initalized;
+}
+
+
+void
+AggregatorService::Run()
+{
+    auto threadNum = max((SPTAG::SizeType)1, GetContext()->GetSettings()->m_threadNum);
+    m_threadPool.reset(new boost::asio::thread_pool(threadNum));
+
+    StartClient();
+    StartListen();
+    WaitForShutdown();
+}
+
+
+void
+AggregatorService::StartClient()
+{
+    auto context = GetContext();
+    Socket::PacketHandlerMapPtr handlerMap(new Socket::PacketHandlerMap);
+    handlerMap->emplace(Socket::PacketType::SearchResponse,
+                        [this](Socket::ConnectionID p_srcID, Socket::Packet p_packet)
+                        {
+                            boost::asio::post(*m_threadPool,
+                                              std::bind(&AggregatorService::SearchResponseHanlder,
+                                                        this,
+                                                        p_srcID,
+                                                        std::move(p_packet)));
+                        });
+
+
+    m_socketClient.reset(new Socket::Client(handlerMap,
+                                            context->GetSettings()->m_socketThreadNum,
+                                            30));
+
+    m_socketClient->SetEventOnConnectionClose([this](Socket::ConnectionID p_cid)
+                                              {
+                                                  auto context = this->GetContext();
+                                                  for (const auto& server : context->GetRemoteServers())
+                                                  {
+                                                      if (nullptr != server && p_cid == server->m_connectionID)
+                                                      {
+                                                          server->m_status = RemoteMachineStatus::Disconnected;
+                                                          this->AddToPendingServers(server);
+                                                      }
+                                                  }
+                                              });
+
+    {
+        std::lock_guard<std::mutex> guard(m_pendingConnectServersMutex);
+        m_pendingConnectServers = context->GetRemoteServers();
+    }
+
+    ConnectToPendingServers();
+}
+
+
+void
+AggregatorService::StartListen()
+{
+    auto context = GetContext();
+    Socket::PacketHandlerMapPtr handlerMap(new Socket::PacketHandlerMap);
+    handlerMap->emplace(Socket::PacketType::SearchRequest,
+                        [this](Socket::ConnectionID p_srcID, Socket::Packet p_packet)
+                        {
+                            boost::asio::post(*m_threadPool,
+                                              std::bind(&AggregatorService::SearchRequestHanlder,
+                                                        this,
+                                                        p_srcID,
+                                                        std::move(p_packet)));
+                        });
+
+    m_socketServer.reset(new Socket::Server(context->GetSettings()->m_listenAddr,
+                                            context->GetSettings()->m_listenPort,
+                                            handlerMap,
+                                            context->GetSettings()->m_socketThreadNum));
+
+    SPTAGLIB_LOG(Helper::LogLevel::LL_Info,
+            "Start to listen %s:%s ...\n",
+            context->GetSettings()->m_listenAddr.c_str(),
+            context->GetSettings()->m_listenPort.c_str());
+}
+
+
+void
+AggregatorService::WaitForShutdown()
+{
+    m_shutdownSignals.add(SIGINT);
+    m_shutdownSignals.add(SIGTERM);
+#ifdef SIGQUIT
+    m_shutdownSignals.add(SIGQUIT);
+#endif
+
+    m_shutdownSignals.async_wait([this](boost::system::error_code p_ec, int p_signal)
+    {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Received shutdown signals.\n");
+        m_pendingConnectServersTimer.cancel();
+    });
+
+    m_ioContext.run();
+    SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Start shutdown procedure.\n");
+
+    m_socketServer.reset();
+    m_threadPool->stop();
+    m_threadPool->join();
+}
+
+
+void
+AggregatorService::ConnectToPendingServers()
+{
+    auto context = GetContext();
+    std::vector<std::shared_ptr<RemoteMachine>> pendingList;
+    pendingList.reserve(context->GetRemoteServers().size());
+
+    {
+        std::lock_guard<std::mutex> guard(m_pendingConnectServersMutex);
+        pendingList.swap(m_pendingConnectServers);
+    }
+
+    for (auto& pendingServer : pendingList)
+    {
+        if (pendingServer->m_status != RemoteMachineStatus::Disconnected)
+        {
+            continue;
+        }
+
+        pendingServer->m_status = RemoteMachineStatus::Connecting;
+        std::shared_ptr<RemoteMachine> server = pendingServer;
+        auto runner = [server, this]()
+                      {
+                          ErrorCode errCode;
+                          auto cid = m_socketClient->ConnectToServer(server->m_address, server->m_port, errCode);
+                          if (Socket::c_invalidConnectionID == cid)
+                          {
+                              if (ErrorCode::Socket_FailedResolveEndPoint == errCode)
+                              {
+                                  SPTAGLIB_LOG(Helper::LogLevel::LL_Error,
+                                          "[Error] Failed to resolve %s %s.\n",
+                                          server->m_address.c_str(),
+                                          server->m_port.c_str());
+                              }
+                              else
+                              {
+                                  this->AddToPendingServers(std::move(server));
+                              }
+                          }
+                          else
+                          {
+                              server->m_connectionID = cid;
+                              server->m_status = RemoteMachineStatus::Connected;
+                          }
+                      };
+        boost::asio::post(*m_threadPool, std::move(runner));
+    }
+
+    m_pendingConnectServersTimer.expires_from_now(boost::posix_time::seconds(30));
+    m_pendingConnectServersTimer.async_wait([this](const boost::system::error_code& p_ec)
+                                            {
+                                                if (boost::asio::error::operation_aborted != p_ec)
+                                                {
+                                                    ConnectToPendingServers();
+                                                }
+                                            });
+}
+
+
+void
+AggregatorService::AddToPendingServers(std::shared_ptr<RemoteMachine> p_remoteServer)
+{
+    std::lock_guard<std::mutex> guard(m_pendingConnectServersMutex);
+    m_pendingConnectServers.emplace_back(std::move(p_remoteServer));
+}
+
+
+void
+AggregatorService::SearchRequestHanlder(Socket::ConnectionID p_localConnectionID, Socket::Packet p_packet)
+{
+    auto context = GetContext();
+    std::vector<Socket::ConnectionID> remoteServers;
+    remoteServers.reserve(context->GetRemoteServers().size());
+
+	if (context->GetSettings()->m_topK > 0 && context->GetRemoteServers().size() == context->GetCenters()->Count()) {
+		Socket::RemoteQuery remoteQuery;
+		remoteQuery.Read(p_packet.Body());
+
+		Service::QueryParser queryParser;
+		queryParser.Parse(remoteQuery.m_queryString, "|");
+		ByteArray vector;
+		size_t vectorSize;
+		SizeType vectorDimension = 0;
+		std::vector<BasicResult> servers;
+		switch (context->GetSettings()->m_valueType)
+		{
+#define DefineVectorValueType(Name, Type) \
+        case VectorValueType::Name: \
+            if (!queryParser.GetVectorElements().empty()) { \
+			    Service::ConvertVectorFromString<Type>(queryParser.GetVectorElements(), vector, vectorDimension); \
+			} else if (queryParser.GetVectorBase64() != nullptr && queryParser.GetVectorBase64Length() != 0) { \
+                vector = ByteArray::Alloc(Helper::Base64::CapacityForDecode(queryParser.GetVectorBase64Length())); \
+                Helper::Base64::Decode(queryParser.GetVectorBase64(), queryParser.GetVectorBase64Length(), vector.Data(), vectorSize); \
+                vectorDimension = (SizeType)(vectorSize / GetValueTypeSize(context->GetSettings()->m_valueType)); \
+            } \
+            for (int i = 0; i < context->GetCenters()->Count(); i++) { \
+                servers.push_back(BasicResult(i, COMMON::DistanceUtils::ComputeDistance((Type*)vector.Data(), \
+                    (Type*)context->GetCenters()->GetVector(i), vectorDimension, context->GetSettings()->m_distMethod))); \
+			} \
+            break; \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineVectorValueType
+
+		default:
+			break;
+		}
+		std::sort(servers.begin(), servers.end(), [](const BasicResult& a, const BasicResult& b) { return a.Dist < b.Dist; });
+		for (int i = 0; i < context->GetSettings()->m_topK; i++) {
+			auto& server = context->GetRemoteServers().at(servers[i].VID);
+			if (RemoteMachineStatus::Connected != server->m_status)
+			{
+				continue;
+			}
+			remoteServers.push_back(server->m_connectionID);
+		}
+	}
+	else {
+		for (const auto& server : context->GetRemoteServers())
+		{
+			if (RemoteMachineStatus::Connected != server->m_status)
+			{
+				continue;
+			}
+
+			remoteServers.push_back(server->m_connectionID);
+		}
+	}
+    Socket::PacketHeader requestHeader = p_packet.Header();
+    if (Socket::c_invalidConnectionID == requestHeader.m_connectionID)
+    {
+        requestHeader.m_connectionID = p_localConnectionID;
+    }
+
+    std::shared_ptr<AggregatorExecutionContext> executionContext(
+        new AggregatorExecutionContext(remoteServers.size(), requestHeader));
+
+    for (std::uint32_t i = 0; i < remoteServers.size(); ++i)
+    {
+        AggregatorCallback callback = [this, executionContext, i](Socket::RemoteSearchResult p_result)
+        {
+            executionContext->GetResult(i).reset(new Socket::RemoteSearchResult(std::move(p_result)));
+            if (executionContext->IsCompletedAfterFinsh(1))
+            {
+                this->AggregateResults(std::move(executionContext));
+            }
+        };
+
+        auto timeoutCallback = [](std::shared_ptr<AggregatorCallback> p_callback)
+        {
+            if (nullptr != p_callback)
+            {
+                Socket::RemoteSearchResult result;
+                result.m_status = Socket::RemoteSearchResult::ResultStatus::Timeout;
+
+                (*p_callback)(std::move(result));
+            }
+        };
+
+        auto connectCallback = [callback](bool p_connectSucc)
+        {
+            if (!p_connectSucc)
+            {
+                Socket::RemoteSearchResult result;
+                result.m_status = Socket::RemoteSearchResult::ResultStatus::FailedNetwork;
+
+                callback(std::move(result));
+            }
+        };
+
+        Socket::Packet packet;
+        packet.Header().m_packetType = Socket::PacketType::SearchRequest;
+        packet.Header().m_processStatus = Socket::PacketProcessStatus::Ok;
+        packet.Header().m_bodyLength = p_packet.Header().m_bodyLength;
+        packet.Header().m_connectionID = Socket::c_invalidConnectionID;
+        packet.Header().m_resourceID = m_aggregatorCallbackManager.Add(std::make_shared<AggregatorCallback>(std::move(callback)),
+                                                                       context->GetSettings()->m_searchTimeout,
+                                                                       std::move(timeoutCallback));
+
+        packet.AllocateBuffer(packet.Header().m_bodyLength);
+        packet.Header().WriteBuffer(packet.HeaderBuffer());
+        memcpy(packet.Body(), p_packet.Body(), packet.Header().m_bodyLength);
+
+        m_socketClient->SendPacket(remoteServers[i], std::move(packet), connectCallback);
+    }
+}
+
+
+void
+AggregatorService::SearchResponseHanlder(Socket::ConnectionID p_localConnectionID, Socket::Packet p_packet)
+{
+    auto callback = m_aggregatorCallbackManager.GetAndRemove(p_packet.Header().m_resourceID);
+    if (nullptr == callback)
+    {
+        return;
+    }
+
+    if (p_packet.Header().m_processStatus != Socket::PacketProcessStatus::Ok || 0 == p_packet.Header().m_bodyLength)
+    {
+        Socket::RemoteSearchResult result;
+        result.m_status = Socket::RemoteSearchResult::ResultStatus::FailedExecute;
+
+        (*callback)(std::move(result));
+    }
+    else
+    {
+        Socket::RemoteSearchResult result;
+        result.Read(p_packet.Body());
+        (*callback)(std::move(result));
+    }
+}
+
+
+std::shared_ptr<AggregatorContext>
+AggregatorService::GetContext()
+{
+    // Add mutex if necessary.
+    return m_aggregatorContext;
+}
+
+
+void
+AggregatorService::AggregateResults(std::shared_ptr<AggregatorExecutionContext> p_exectionContext)
+{
+    if (nullptr == p_exectionContext)
+    {
+        return;
+    }
+
+    Socket::Packet packet;
+    packet.Header().m_packetType = Socket::PacketType::SearchResponse;
+    packet.Header().m_processStatus = Socket::PacketProcessStatus::Ok;
+    packet.Header().m_resourceID = p_exectionContext->GetRequestHeader().m_resourceID;
+
+    Socket::RemoteSearchResult remoteResult;
+    remoteResult.m_status = Socket::RemoteSearchResult::ResultStatus::Success;
+
+    std::size_t resultNum = 0;
+    for (std::size_t i = 0; i < p_exectionContext->GetServerNumber(); ++i)
+    {
+        const auto& result = p_exectionContext->GetResult(i);
+        if (nullptr == result)
+        {
+            continue;
+        }
+
+        resultNum += result->m_allIndexResults.size();
+    }
+
+    remoteResult.m_allIndexResults.reserve(resultNum);
+    for (std::size_t i = 0; i < p_exectionContext->GetServerNumber(); ++i)
+    {
+        const auto& result = p_exectionContext->GetResult(i);
+        if (nullptr == result)
+        {
+            continue;
+        }
+
+        for (auto& indexRes : result->m_allIndexResults)
+        {
+            remoteResult.m_allIndexResults.emplace_back(std::move(indexRes));
+        }
+    }
+
+    std::uint32_t cap = static_cast<std::uint32_t>(remoteResult.EstimateBufferSize());
+    packet.AllocateBuffer(cap);
+    packet.Header().m_bodyLength = static_cast<std::uint32_t>(remoteResult.Write(packet.Body()) - packet.Body());
+    packet.Header().WriteBuffer(packet.HeaderBuffer());
+
+    m_socketServer->SendPacket(p_exectionContext->GetRequestHeader().m_connectionID,
+                               std::move(packet),
+                               nullptr);
+}

SPANN/AnnService/src/Aggregator/AggregatorSettings.cpp

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Aggregator/AggregatorSettings.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Aggregator;
+
+AggregatorSettings::AggregatorSettings()
+    : m_searchTimeout(100),
+      m_threadNum(8),
+      m_socketThreadNum(8)
+{
+}

SPANN/AnnService/src/Aggregator/main.cpp

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Aggregator/AggregatorService.h"
+
+SPTAG::Aggregator::AggregatorService g_service;
+
+int main(int argc, char* argv[])
+{
+    if (!g_service.Initialize())
+    {
+        return 1;
+    }
+
+    g_service.Run();
+
+    return 0;
+}
+

SPANN/AnnService/src/Helper/ArgumentsParser.cpp

@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/ArgumentsParser.h"
+
+using namespace SPTAG::Helper;
+
+
+ArgumentsParser::IArgument::IArgument()
+{
+}
+
+
+ArgumentsParser::IArgument::~IArgument()
+{
+}
+
+
+ArgumentsParser::ArgumentsParser()
+{
+}
+
+
+ArgumentsParser::~ArgumentsParser()
+{
+}
+
+
+bool
+ArgumentsParser::Parse(int p_argc, char** p_args)
+{
+    while (p_argc > 0)
+    {
+        int last = p_argc;
+        for (auto& option : m_arguments)
+        {
+            if (!option->ParseValue(p_argc, p_args))
+            {
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Empty, "Failed to parse args around \"%s\"\n", *p_args);
+                PrintHelp();
+                return false;
+            }
+        }
+
+        if (last == p_argc)
+        {
+            p_argc -= 1;
+            p_args += 1;
+        }
+    }
+
+    bool isValid = true;
+    for (auto& option : m_arguments)
+    {
+        if (option->IsRequiredButNotSet())
+        {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Empty, "Required option not set:\n  ");
+            option->PrintDescription();
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Empty, "\n");
+            isValid = false;
+        }
+    }
+
+    if (!isValid)
+    {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Empty, "\n");
+        PrintHelp();
+        return false;
+    }
+
+    return true;
+}
+
+
+void
+ArgumentsParser::PrintHelp()
+{
+    SPTAGLIB_LOG(Helper::LogLevel::LL_Empty, "Usage: ");
+    for (auto& option : m_arguments)
+    {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Empty, "\n  ");
+        option->PrintDescription();
+    }
+
+    SPTAGLIB_LOG(Helper::LogLevel::LL_Empty, "\n\n");
+}

SPANN/AnnService/src/Helper/AsyncFileReader.cpp

@@ -0,0 +1,202 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/AsyncFileReader.h"
+
+namespace SPTAG {
+    namespace Helper {
+#ifndef _MSC_VER
+        void SetThreadAffinity(int threadID, std::thread& thread, NumaStrategy socketStrategy, OrderStrategy idStrategy)
+        {
+#ifdef NUMA
+            int numGroups = numa_num_task_nodes();
+            int numCpus = numa_num_task_cpus() / numGroups;
+
+            int group = threadID / numCpus;
+            int cpuid = threadID % numCpus;
+            if (socketStrategy == NumaStrategy::SCATTER) {
+                group = threadID % numGroups;
+                cpuid = (threadID / numGroups) % numCpus;
+            }
+
+            struct bitmask* cpumask = numa_allocate_cpumask();
+            if (!numa_node_to_cpus(group, cpumask)) {
+                unsigned int nodecpu = 0;
+                for (unsigned int i = 0; i < cpumask->size; i++) {
+                    if (numa_bitmask_isbitset(cpumask, i)) {
+                        if (cpuid == nodecpu) {
+                            cpu_set_t cpuset;
+                            CPU_ZERO(&cpuset);
+                            CPU_SET(i, &cpuset);
+                            int rc = pthread_setaffinity_np(thread.native_handle(), sizeof(cpu_set_t), &cpuset);
+                            if (rc != 0) {
+                                SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Error calling pthread_setaffinity_np for thread %d: %d\n", threadID, rc);
+                            }
+                            break;
+                        }
+                        nodecpu++;
+                    }
+                }
+            }
+#else
+            cpu_set_t cpuset;
+            CPU_ZERO(&cpuset);
+            CPU_SET(threadID, &cpuset);
+            int rc = pthread_setaffinity_np(thread.native_handle(), sizeof(cpu_set_t), &cpuset);
+            if (rc != 0) {
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Error calling pthread_setaffinity_np for thread %d: %d\n", threadID, rc);
+            }
+#endif
+        }
+
+        struct timespec AIOTimeout {0, 30000};
+        void BatchReadFileAsync(std::vector<std::shared_ptr<Helper::DiskIO>>& handlers, AsyncReadRequest* readRequests, int num)
+        {
+            std::vector<struct iocb> myiocbs(num);
+            std::vector<std::vector<struct iocb*>> iocbs(handlers.size());
+            std::vector<int> submitted(handlers.size(), 0);
+            std::vector<int> done(handlers.size(), 0);
+            int totalToSubmit = 0, channel = 0;
+
+            memset(myiocbs.data(), 0, num * sizeof(struct iocb));
+            for (int i = 0; i < num; i++) {
+                AsyncReadRequest* readRequest = &(readRequests[i]);
+
+                channel = readRequest->m_status & 0xffff;
+                int fileid = (readRequest->m_status >> 16);
+
+                struct iocb* myiocb = &(myiocbs[totalToSubmit++]);
+                myiocb->aio_data = reinterpret_cast<uintptr_t>(readRequest);
+                myiocb->aio_lio_opcode = IOCB_CMD_PREAD;
+                myiocb->aio_fildes = ((AsyncFileIO*)(handlers[fileid].get()))->GetFileHandler();
+                myiocb->aio_buf = (std::uint64_t)(readRequest->m_buffer);
+                myiocb->aio_nbytes = readRequest->m_readSize;
+                myiocb->aio_offset = static_cast<std::int64_t>(readRequest->m_offset);
+
+                iocbs[fileid].emplace_back(myiocb);
+            }
+            std::vector<struct io_event> events(totalToSubmit);
+            int totalDone = 0, totalSubmitted = 0, totalQueued = 0;
+            while (totalDone < totalToSubmit) {
+                if (totalSubmitted < totalToSubmit) {
+                    for (int i = 0; i < handlers.size(); i++) {
+                        if (submitted[i] < iocbs[i].size()) {
+                            AsyncFileIO* handler = (AsyncFileIO*)(handlers[i].get());
+                            int s = syscall(__NR_io_submit, handler->GetIOCP(channel), iocbs[i].size() - submitted[i], iocbs[i].data() + submitted[i]);
+                            if (s > 0) {
+                                submitted[i] += s;
+                                totalSubmitted += s;
+                            }
+                            else {
+                                SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "fid:%d channel %d, to submit:%d, submitted:%s\n", i, channel, iocbs[i].size() - submitted[i], strerror(-s));
+                            }
+                        }
+                    }
+                }
+
+                for (int i = totalQueued; i < totalDone; i++) {
+                    AsyncReadRequest* req = reinterpret_cast<AsyncReadRequest*>((events[i].data));
+                    if (nullptr != req)
+                    {
+                        req->m_callback(true);
+                    }
+                }
+                totalQueued = totalDone;
+
+                for (int i = 0; i < handlers.size(); i++) {
+                    if (done[i] < submitted[i]) {
+                        int wait = submitted[i] - done[i];
+                        AsyncFileIO* handler = (AsyncFileIO*)(handlers[i].get());
+                        auto d = syscall(__NR_io_getevents, handler->GetIOCP(channel), wait, wait, events.data() + totalDone, &AIOTimeout);
+                        done[i] += d;
+                        totalDone += d;
+                    }
+                }
+            }
+
+            for (int i = totalQueued; i < totalDone; i++) {
+                AsyncReadRequest* req = reinterpret_cast<AsyncReadRequest*>((events[i].data));
+                if (nullptr != req)
+                {
+                    req->m_callback(true);
+                }
+            }
+        }
+#else
+        ULONGLONG GetCpuMasks(WORD group, DWORD numCpus)
+        {
+            ULONGLONG masks = 0, mask = 1;
+            for (DWORD i = 0; i < numCpus; ++i)
+            {
+                masks |= mask;
+                mask <<= 1;
+            }
+
+            return masks;
+        }
+
+        void SetThreadAffinity(int threadID, std::thread& thread, NumaStrategy socketStrategy, OrderStrategy idStrategy)
+        {
+            WORD numGroups = GetActiveProcessorGroupCount();
+            DWORD numCpus = GetActiveProcessorCount(0);
+
+            GROUP_AFFINITY ga;
+            memset(&ga, 0, sizeof(ga));
+            PROCESSOR_NUMBER pn;
+            memset(&pn, 0, sizeof(pn));
+
+            WORD group = (WORD)(threadID / numCpus);
+            pn.Number = (BYTE)(threadID % numCpus);
+            if (socketStrategy == NumaStrategy::SCATTER) {
+                group = (WORD)(threadID % numGroups);
+                pn.Number = (BYTE)((threadID / numGroups) % numCpus);
+            }
+
+            ga.Group = group;
+            ga.Mask = GetCpuMasks(group, numCpus);
+            BOOL res = SetThreadGroupAffinity(GetCurrentThread(), &ga, NULL);
+            if (!res)
+            {
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed SetThreadGroupAffinity for group %d and mask %I64x for thread %d.\n", ga.Group, ga.Mask, threadID);
+                return;
+            }
+            pn.Group = group;
+            if (idStrategy == OrderStrategy::DESC) {
+                pn.Number = (BYTE)(numCpus - 1 - pn.Number);
+            }
+            res = SetThreadIdealProcessorEx(GetCurrentThread(), &pn, NULL);
+            if (!res)
+            {
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to set ideal processor for thread %d.\n", threadID);
+                return;
+            }
+
+            //SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "numGroup:%d numCPUs:%d threadID:%d group:%d cpuid:%d\n", (int)(numGroups), (int)numCpus, threadID, (int)(group), (int)(pn.Number));
+            YieldProcessor();
+        }
+
+        void BatchReadFileAsync(std::vector<std::shared_ptr<Helper::DiskIO>>& handlers, AsyncReadRequest* readRequests, int num)
+        {
+            if (handlers.size() == 1) {
+                handlers[0]->BatchReadFile(readRequests, num);
+            }
+            else {
+                int currFileId = 0, currReqStart = 0;
+                for (int i = 0; i < num; i++) {
+                    AsyncReadRequest* readRequest = &(readRequests[i]);
+
+                    int fileid = (readRequest->m_status >> 16);
+                    if (fileid != currFileId) {
+                        handlers[currFileId]->BatchReadFile(readRequests + currReqStart, i - currReqStart);
+                        currFileId = fileid;
+                        currReqStart = i;
+                    }
+                }
+                if (currReqStart < num) {
+                    handlers[currFileId]->BatchReadFile(readRequests + currReqStart, num - currReqStart);
+                }
+            }
+        }
+#endif
+    }
+}

SPANN/AnnService/src/Helper/Base64Encode.cpp

@@ -0,0 +1,240 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/Base64Encode.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Helper;
+
+namespace
+{
+namespace Local
+{
+const char c_encTable[] =
+{
+    'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
+    'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
+    '0','1','2','3','4','5','6','7','8','9','+','/'
+};
+
+
+const std::uint8_t c_decTable[] =
+{
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0x00 - 0x0f
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0x10 - 0x1f
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 64, 64, 63, // 0x20 - 0x2f
+    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64, // 0x30 - 0x3f
+    64,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, // 0x40 - 0x4f
+    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 64, // 0x50 - 0x5f
+    64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, // 0x60 - 0x6f
+    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64, // 0x70 - 0x7f
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0x80 - 0x8f
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0x90 - 0x9f
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0xa0 - 0xaf
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0xb0 - 0xbf
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0xc0 - 0xcf
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0xd0 - 0xdf
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0xe0 - 0xef
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0xf0 - 0xff
+};
+
+
+const char c_paddingChar = '=';
+}
+}
+
+
+bool
+Base64::Encode(const std::uint8_t* p_in, std::size_t p_inLen, char* p_out, std::size_t& p_outLen)
+{
+    using namespace Local;
+
+    p_outLen = 0;
+    while (p_inLen >= 3)
+    {
+        p_out[0] = c_encTable[p_in[0] >> 2];
+        p_out[1] = c_encTable[((p_in[0] & 0x03) << 4) | ((p_in[1] & 0xf0) >> 4)];
+        p_out[2] = c_encTable[((p_in[1] & 0x0f) << 2) | ((p_in[2] & 0xc0) >> 6)];
+        p_out[3] = c_encTable[p_in[2] & 0x3f];
+
+        p_in += 3;
+        p_inLen -= 3;
+        p_out += 4;
+        p_outLen += 4;
+    }
+
+    switch (p_inLen)
+    {
+    case 1:
+        p_out[0] = c_encTable[p_in[0] >> 2];
+        p_out[1] = c_encTable[(p_in[0] & 0x03) << 4];
+        p_out[2] = c_paddingChar;
+        p_out[3] = c_paddingChar;
+
+        p_outLen += 4;
+        break;
+
+    case 2:
+        p_out[0] = c_encTable[p_in[0] >> 2];
+        p_out[1] = c_encTable[((p_in[0] & 0x03) << 4) | ((p_in[1] & 0xf0) >> 4)];
+        p_out[2] = c_encTable[(p_in[1] & 0x0f) << 2];
+        p_out[3] = c_paddingChar;
+
+        p_outLen += 4;
+        break;
+    }
+
+    return true;
+}
+
+
+bool
+Base64::Encode(const std::uint8_t* p_in, std::size_t p_inLen, std::ostream& p_out, std::size_t& p_outLen)
+{
+        using namespace Local;
+
+    p_outLen = 0;
+    while (p_inLen >= 3)
+    {
+        p_out << c_encTable[p_in[0] >> 2];
+        p_out << c_encTable[((p_in[0] & 0x03) << 4) | ((p_in[1] & 0xf0) >> 4)];
+        p_out << c_encTable[((p_in[1] & 0x0f) << 2) | ((p_in[2] & 0xc0) >> 6)];
+        p_out << c_encTable[p_in[2] & 0x3f];
+
+        p_in += 3;
+        p_inLen -= 3;
+        p_outLen += 4;
+    }
+
+    switch (p_inLen)
+    {
+    case 1:
+        p_out << c_encTable[p_in[0] >> 2];
+        p_out << c_encTable[(p_in[0] & 0x03) << 4];
+        p_out << c_paddingChar;
+        p_out << c_paddingChar;
+
+        p_outLen += 4;
+        break;
+
+    case 2:
+        p_out << c_encTable[p_in[0] >> 2];
+        p_out << c_encTable[((p_in[0] & 0x03) << 4) | ((p_in[1] & 0xf0) >> 4)];
+        p_out << c_encTable[(p_in[1] & 0x0f) << 2];
+        p_out << c_paddingChar;
+
+        p_outLen += 4;
+        break;
+
+    default:
+        break;
+    }
+
+    return true;
+}
+
+
+bool
+Base64::Decode(const char* p_in, std::size_t p_inLen, std::uint8_t* p_out, std::size_t& p_outLen)
+{
+    using namespace Local;
+
+    // Should always be padding.
+    if ((p_inLen & 0x03) != 0)
+    {
+        return false;
+    }
+
+    std::uint8_t u0 = 0;
+    std::uint8_t u1 = 0;
+    std::uint8_t u2 = 0;
+    std::uint8_t u3 = 0;
+
+    p_outLen = 0;
+    while (p_inLen > 4)
+    {
+        u0 = c_decTable[static_cast<std::size_t>(p_in[0])];
+        u1 = c_decTable[static_cast<std::size_t>(p_in[1])];
+        u2 = c_decTable[static_cast<std::size_t>(p_in[2])];
+        u3 = c_decTable[static_cast<std::size_t>(p_in[3])];
+
+        if (u0 > 63 || u1 > 63 || u2 > 63 || u3 > 63)
+        {
+            return false;
+        }
+
+        p_out[0] = (u0 << 2) | (u1 >> 4);
+        p_out[1] = (u1 << 4) | (u2 >> 2);
+        p_out[2] = (u2 << 6) | u3;
+
+        p_inLen -= 4;
+        p_in += 4;
+        p_out += 3;
+        p_outLen += 3;
+    }
+
+    u0 = c_decTable[static_cast<std::size_t>(p_in[0])];
+    u1 = c_decTable[static_cast<std::size_t>(p_in[1])];
+    u2 = c_decTable[static_cast<std::size_t>(p_in[2])];
+    u3 = c_decTable[static_cast<std::size_t>(p_in[3])];
+
+    if (u0 > 63 || u1 > 63 || (c_paddingChar == p_in[2] && c_paddingChar != p_in[3]))
+    {
+        return false;
+    }
+
+    if (u2 > 63 && c_paddingChar != p_in[2])
+    {
+        return false;
+    }
+
+    if (u3 > 63 && c_paddingChar != p_in[3])
+    {
+        return false;
+    }
+
+
+    p_out[0] = (u0 << 2) | (u1 >> 4);
+    ++p_outLen;
+    if (c_paddingChar == p_in[2])
+    {
+        if ((u1 & 0x0F) != 0)
+        {
+            return false;
+        }
+    }
+    else
+    {
+        p_out[1] = (u1 << 4) | (u2 >> 2);
+        ++p_outLen;
+        if (c_paddingChar == p_in[3])
+        {
+            if ((u3 & 0x03) != 0)
+            {
+                return false;
+            }
+        }
+        else
+        {
+            p_out[2] = (u2 << 6) | u3;
+            ++p_outLen;
+        }
+    }
+
+    return true;
+}
+
+
+std::size_t
+Base64::CapacityForEncode(std::size_t p_inLen)
+{
+    return ((p_inLen + 2) / 3) * 4;
+}
+
+
+std::size_t
+Base64::CapacityForDecode(std::size_t p_inLen)
+{
+    return (p_inLen / 4) * 3 + ((p_inLen % 4) * 2) / 3;
+}
+

SPANN/AnnService/src/Helper/CommonHelper.cpp

@@ -0,0 +1,157 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/CommonHelper.h"
+
+#include <cctype>
+#include <functional>
+
+using namespace SPTAG;
+using namespace SPTAG::Helper;
+
+void
+StrUtils::ToLowerInPlace(std::string& p_str)
+{
+    for (char& ch : p_str)
+    {
+        if (std::isupper(ch))
+        {
+            ch = ch | 0x20;
+        }
+    }
+}
+
+
+std::vector<std::string>
+StrUtils::SplitString(const std::string& p_str, const std::string& p_separator)
+{
+    std::vector<std::string> ret;
+
+    std::size_t begin = p_str.find_first_not_of(p_separator);
+    while (std::string::npos != begin)
+    {
+        std::size_t end = p_str.find_first_of(p_separator, begin);
+        if (std::string::npos == end)
+        {
+            ret.emplace_back(p_str.substr(begin, p_str.size() - begin));
+            break;
+        }
+        else
+        {
+            ret.emplace_back(p_str.substr(begin, end - begin));
+        }
+
+        begin = p_str.find_first_not_of(p_separator, end);
+    }
+
+    return ret;
+}
+
+
+std::pair<const char*, const char*>
+StrUtils::FindTrimmedSegment(const char* p_begin,
+                             const char* p_end,
+                             const std::function<bool(char)>& p_isSkippedChar)
+{
+    while (p_begin < p_end)
+    {
+        if (!p_isSkippedChar(*p_begin))
+        {
+            break;
+        }
+
+        ++p_begin;
+    }
+
+    while (p_end > p_begin)
+    {
+        if (!p_isSkippedChar(*(p_end - 1)))
+        {
+            break;
+        }
+
+        --p_end;
+    }
+
+    return std::make_pair(p_begin, p_end);
+}
+
+
+bool
+StrUtils::StartsWith(const char* p_str, const char* p_prefix)
+{
+    if (nullptr == p_prefix)
+    {
+        return true;
+    }
+
+    if (nullptr == p_str)
+    {
+        return false;
+    }
+
+    while ('\0' != (*p_prefix) && '\0' != (*p_str))
+    {
+        if (*p_prefix != *p_str)
+        {
+            return false;
+        }
+        ++p_prefix;
+        ++p_str;
+    }
+
+    return '\0' == *p_prefix;
+}
+
+
+bool
+StrUtils::StrEqualIgnoreCase(const char* p_left, const char* p_right)
+{
+    if (p_left == p_right)
+    {
+        return true;
+    }
+
+    if (p_left == nullptr || p_right == nullptr)
+    {
+        return false;
+    }
+
+    auto tryConv = [](char p_ch) -> char
+    {
+        if ('a' <= p_ch && p_ch <= 'z')
+        {
+            return p_ch - 32;
+        }
+
+        return p_ch;
+    };
+
+    while (*p_left != '\0' && *p_right != '\0')
+    {
+        if (tryConv(*p_left) != tryConv(*p_right))
+        {
+            return false;
+        }
+
+        ++p_left;
+        ++p_right;
+    }
+
+    return *p_left == *p_right;
+}
+
+
+std::string
+StrUtils::ReplaceAll(const std::string& orig, const std::string& from, const std::string& to)
+{
+    std::string ret = orig;
+    if (from.empty()) return ret;
+
+    size_t pos = 0;
+    while ((pos = ret.find(from, pos)) != std::string::npos) {
+        ret.replace(pos, from.length(), to);
+        pos += to.length();
+    }
+    return ret;
+}

SPANN/AnnService/src/Helper/DynamicNeighbors.cpp

@@ -0,0 +1,86 @@
+#include "inc/Helper/DynamicNeighbors.h"
+#include "inc/Core/Common.h"
+
+using namespace SPTAG::Helper;
+
+DynamicNeighbors::DynamicNeighbors(const int* p_data, const int p_length)
+    : c_data(p_data),
+    c_length(p_length)
+{
+}
+
+
+DynamicNeighbors:: ~DynamicNeighbors()
+{
+}
+
+
+int
+DynamicNeighbors::operator[](const int p_id) const
+{
+    if (p_id < c_length && p_id >= 0)
+    {
+        return c_data[p_id];
+    }
+
+    return -1;
+}
+
+
+int
+DynamicNeighbors::Size() const
+{
+    return c_length;
+}
+
+
+DynamicNeighborsSet::DynamicNeighborsSet(const char* p_filePath)
+{
+    auto fp = f_createIO();
+    if (fp == nullptr || !fp->Initialize(p_filePath, std::ios::binary | std::ios::in)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed open graph file: %s\n", p_filePath);
+        throw std::runtime_error("Opening graph file failed");
+    }
+
+    if (fp->ReadBinary(sizeof(m_vectorCount), (char*)&m_vectorCount) != sizeof(m_vectorCount)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read DynamicNeighborsSet!\n");
+        throw std::runtime_error("reading DynamicNeighborsSet failed");
+    }
+
+    m_neighborOffset.reset(new int[m_vectorCount + 1]);
+    m_neighborOffset[0] = 0;
+    if (fp->ReadBinary(m_vectorCount * sizeof(int), (char*)(m_neighborOffset.get() + 1)) != m_vectorCount * sizeof(int)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read DynamicNeighborsSet!\n");
+        throw std::runtime_error("reading DynamicNeighborsSet failed");
+    }
+
+    size_t graphSize = static_cast<size_t>(m_neighborOffset[m_vectorCount]);
+    SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Vector count: %d, Graph size: %zu\n", m_vectorCount, graphSize);
+
+    m_data.reset(new int[graphSize]);
+    auto readSize = fp->ReadBinary(graphSize * sizeof(int), (char*)(m_data.get()));
+    if (readSize != graphSize * sizeof(int)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error,
+            "Failed read graph: size not match, expected %zu, actually %zu\n",
+            static_cast<size_t>(graphSize * sizeof(int)),
+            static_cast<size_t>(readSize));
+        throw std::runtime_error("Graph size doesn't match expected");
+    }
+}
+
+
+DynamicNeighborsSet::~DynamicNeighborsSet()
+{
+}
+
+
+DynamicNeighbors DynamicNeighborsSet::operator[](const int p_id) const
+{
+    if (p_id >= m_vectorCount)
+    {
+        return DynamicNeighbors(nullptr, 0);
+    }
+
+    return DynamicNeighbors(m_data.get() + static_cast<uint64_t>(m_neighborOffset[p_id]),
+        m_neighborOffset[p_id + 1] - m_neighborOffset[p_id]);
+}

SPANN/AnnService/src/Helper/SimpleIniReader.cpp

@@ -0,0 +1,235 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/SimpleIniReader.h"
+#include "inc/Helper/CommonHelper.h"
+
+#include <cctype>
+#include <functional>
+
+using namespace SPTAG;
+using namespace SPTAG::Helper;
+
+const IniReader::ParameterValueMap IniReader::c_emptyParameters;
+
+
+IniReader::IniReader()
+{
+}
+
+
+IniReader::~IniReader()
+{
+}
+
+
+ErrorCode IniReader::LoadIni(std::shared_ptr<Helper::DiskIO> p_input)
+{
+    std::uint64_t c_bufferSize = 1 << 16;
+
+    std::unique_ptr<char[]> line(new char[c_bufferSize]);
+
+    std::string currSection;
+    std::shared_ptr<ParameterValueMap> currParamMap(new ParameterValueMap);
+
+    if (m_parameters.count(currSection) == 0)
+    {
+        m_parameters.emplace(currSection, currParamMap);
+    }
+
+    auto isSpace = [](char p_ch) -> bool
+    {
+        return std::isspace(p_ch) != 0;
+    };
+
+    while (true)
+    {
+        if (!p_input->ReadString(c_bufferSize, line)) break;
+
+        std::uint64_t len = 0;
+        while (len < c_bufferSize && line[len] != '\0')
+        {
+            ++len;
+        }
+
+        auto nonSpaceSeg = StrUtils::FindTrimmedSegment(line.get(), line.get() + len, isSpace);
+
+        if (nonSpaceSeg.second <= nonSpaceSeg.first)
+        {
+            // Blank line.
+            continue;
+        }
+
+        if (';' == *nonSpaceSeg.first)
+        {
+            // Comments.
+            continue;
+        }
+        else if ('[' == *nonSpaceSeg.first)
+        {
+            // Parse Section
+            if (']' != *(nonSpaceSeg.second - 1))
+            {
+                return ErrorCode::ReadIni_FailedParseSection;
+            }
+
+            auto sectionSeg = StrUtils::FindTrimmedSegment(nonSpaceSeg.first + 1, nonSpaceSeg.second - 1, isSpace);
+
+            if (sectionSeg.second <= sectionSeg.first)
+            {
+                // Empty section name.
+                return ErrorCode::ReadIni_FailedParseSection;
+            }
+
+            currSection.assign(sectionSeg.first, sectionSeg.second);
+            StrUtils::ToLowerInPlace(currSection);
+
+            if (m_parameters.count(currSection) == 0)
+            {
+                currParamMap.reset(new ParameterValueMap);
+                m_parameters.emplace(currSection, currParamMap);
+            }
+            else
+            {
+                return ErrorCode::ReadIni_DuplicatedSection;
+            }
+        }
+        else
+        {
+            // Parameter Value Pair.
+            const char* equalSignLoc = nonSpaceSeg.first;
+            while (equalSignLoc < nonSpaceSeg.second && '=' != *equalSignLoc)
+            {
+                ++equalSignLoc;
+            }
+
+            if (equalSignLoc >= nonSpaceSeg.second)
+            {
+                return ErrorCode::ReadIni_FailedParseParam;
+            }
+
+            auto paramSeg = StrUtils::FindTrimmedSegment(nonSpaceSeg.first, equalSignLoc, isSpace);
+
+            if (paramSeg.second <= paramSeg.first)
+            {
+                // Empty parameter name.
+                return ErrorCode::ReadIni_FailedParseParam;
+            }
+
+            std::string paramName(paramSeg.first, paramSeg.second);
+            StrUtils::ToLowerInPlace(paramName);
+
+            if (currParamMap->count(paramName) == 0)
+            {
+                currParamMap->emplace(std::move(paramName), std::string(equalSignLoc + 1, nonSpaceSeg.second));
+            }
+            else
+            {
+                return ErrorCode::ReadIni_DuplicatedParam;
+            }
+        }
+    }
+    return ErrorCode::Success;
+}
+
+
+ErrorCode
+IniReader::LoadIniFile(const std::string& p_iniFilePath)
+{
+    auto ptr = f_createIO();
+    if (ptr == nullptr || !ptr->Initialize(p_iniFilePath.c_str(), std::ios::in)) return ErrorCode::FailedOpenFile;
+    return LoadIni(ptr);
+}
+
+
+bool
+IniReader::DoesSectionExist(const std::string& p_section) const
+{
+    std::string section(p_section);
+    StrUtils::ToLowerInPlace(section);
+    return m_parameters.count(section) != 0;
+}
+
+
+bool
+IniReader::DoesParameterExist(const std::string& p_section, const std::string& p_param) const
+{
+    std::string name(p_section);
+    StrUtils::ToLowerInPlace(name);
+    auto iter = m_parameters.find(name);
+    if (iter == m_parameters.cend())
+    {
+        return false;
+    }
+
+    const auto& paramMap = iter->second;
+    if (paramMap == nullptr)
+    {
+        return false;
+    }
+
+    name = p_param;
+    StrUtils::ToLowerInPlace(name);
+    return paramMap->count(name) != 0;
+}
+
+
+bool
+IniReader::GetRawValue(const std::string& p_section, const std::string& p_param, std::string& p_value) const
+{
+    std::string name(p_section);
+    StrUtils::ToLowerInPlace(name);
+    auto sectionIter = m_parameters.find(name);
+    if (sectionIter == m_parameters.cend())
+    {
+        return false;
+    }
+
+    const auto& paramMap = sectionIter->second;
+    if (paramMap == nullptr)
+    {
+        return false;
+    }
+
+    name = p_param;
+    StrUtils::ToLowerInPlace(name);
+    auto paramIter = paramMap->find(name);
+    if (paramIter == paramMap->cend())
+    {
+        return false;
+    }
+
+    p_value = paramIter->second;
+    return true;
+}
+
+
+const IniReader::ParameterValueMap&
+IniReader::GetParameters(const std::string& p_section) const
+{
+    std::string name(p_section);
+    StrUtils::ToLowerInPlace(name);
+    auto sectionIter = m_parameters.find(name);
+    if (sectionIter == m_parameters.cend() || nullptr == sectionIter->second)
+    {
+        return c_emptyParameters;
+    }
+
+    return *(sectionIter->second);
+}
+
+void
+IniReader::SetParameter(const std::string& p_section, const std::string& p_param, const std::string& p_val)
+{
+    std::string name(p_section);
+    StrUtils::ToLowerInPlace(name);
+    auto sectionIter = m_parameters.find(name);
+    if (sectionIter == m_parameters.cend() || sectionIter->second == nullptr) 
+    {
+        m_parameters[name] = std::shared_ptr<ParameterValueMap>(new ParameterValueMap);
+    }
+
+    std::string param(p_param);
+    StrUtils::ToLowerInPlace(param);
+    (*m_parameters[name])[param] = p_val;
+}

SPANN/AnnService/src/Helper/VectorSetReader.cpp

@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/VectorSetReader.h"
+#include "inc/Helper/VectorSetReaders/DefaultReader.h"
+#include "inc/Helper/VectorSetReaders/TxtReader.h"
+#include "inc/Helper/VectorSetReaders/XvecReader.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Helper;
+
+
+ReaderOptions::ReaderOptions(VectorValueType p_valueType, DimensionType p_dimension, VectorFileType p_fileType, std::string p_vectorDelimiter, std::uint32_t p_threadNum, bool p_normalized)
+    :  m_inputValueType(p_valueType), m_dimension(p_dimension), m_inputFileType(p_fileType), m_vectorDelimiter(p_vectorDelimiter), m_threadNum(p_threadNum), m_normalized(p_normalized)
+{
+    AddOptionalOption(m_threadNum, "-t", "--thread", "Thread Number.");
+    AddOptionalOption(m_vectorDelimiter, "-dl", "--delimiter", "Vector delimiter.");
+    AddOptionalOption(m_normalized, "-norm", "--normalized", "Vector is normalized.");
+    AddRequiredOption(m_dimension, "-d", "--dimension", "Dimension of vector.");
+    AddRequiredOption(m_inputValueType, "-v", "--vectortype", "Input vector data type. Default is float.");
+    AddRequiredOption(m_inputFileType, "-f", "--filetype", "Input file type (DEFAULT, TXT, XVEC). Default is DEFAULT.");
+}
+
+
+ReaderOptions::~ReaderOptions()
+{
+}
+
+
+VectorSetReader::VectorSetReader(std::shared_ptr<ReaderOptions> p_options)
+    : m_options(p_options)
+{
+}
+
+
+VectorSetReader:: ~VectorSetReader()
+{
+}
+
+
+std::shared_ptr<VectorSetReader>
+VectorSetReader::CreateInstance(std::shared_ptr<ReaderOptions> p_options)
+{
+    if (p_options->m_inputFileType == VectorFileType::DEFAULT) {
+        return std::make_shared<DefaultVectorReader>(p_options);
+    }
+    else if (p_options->m_inputFileType == VectorFileType::TXT) {
+        return std::make_shared<TxtVectorReader>(p_options);
+    }
+    else if (p_options->m_inputFileType == VectorFileType::XVEC) {
+        return std::make_shared<XvecVectorReader>(p_options);
+    }
+    return nullptr;
+}
+
+

SPANN/AnnService/src/Helper/VectorSetReaders/DefaultReader.cpp

@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/VectorSetReaders/DefaultReader.h"
+#include "inc/Helper/CommonHelper.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Helper;
+
+DefaultVectorReader::DefaultVectorReader(std::shared_ptr<ReaderOptions> p_options)
+    : VectorSetReader(p_options)
+{
+    m_vectorOutput = "";
+    m_metadataConentOutput = "";
+    m_metadataIndexOutput = "";
+}
+
+
+DefaultVectorReader::~DefaultVectorReader()
+{
+}
+
+
+ErrorCode
+DefaultVectorReader::LoadFile(const std::string& p_filePaths)
+{
+    const auto& files = SPTAG::Helper::StrUtils::SplitString(p_filePaths, ",");
+    m_vectorOutput = files[0];
+    if (files.size() >= 3) {
+        m_metadataConentOutput = files[1];
+        m_metadataIndexOutput = files[2];
+    }
+    return ErrorCode::Success;
+}
+
+
+std::shared_ptr<VectorSet>
+DefaultVectorReader::GetVectorSet(SizeType start, SizeType end) const
+{
+    auto ptr = f_createIO();
+    if (ptr == nullptr || !ptr->Initialize(m_vectorOutput.c_str(), std::ios::binary | std::ios::in)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read file %s.\n", m_vectorOutput.c_str());
+        throw std::runtime_error("Failed read file");
+    }
+
+    SizeType row;
+    DimensionType col;
+    if (ptr->ReadBinary(sizeof(SizeType), (char*)&row) != sizeof(SizeType)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read VectorSet!\n");
+        throw std::runtime_error("Failed read file");
+    }
+    if (ptr->ReadBinary(sizeof(DimensionType), (char*)&col) != sizeof(DimensionType)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read VectorSet!\n");
+        throw std::runtime_error("Failed read file");
+    }
+    
+    if (start > row) start = row;
+    if (end < 0 || end > row) end = row;
+    std::uint64_t totalRecordVectorBytes = ((std::uint64_t)GetValueTypeSize(m_options->m_inputValueType)) * (end - start) * col;
+    ByteArray vectorSet;
+    if (totalRecordVectorBytes > 0) {
+        vectorSet = ByteArray::Alloc(totalRecordVectorBytes);
+        char* vecBuf = reinterpret_cast<char*>(vectorSet.Data());
+        std::uint64_t offset = ((std::uint64_t)GetValueTypeSize(m_options->m_inputValueType)) * start * col + sizeof(SizeType) + sizeof(DimensionType);
+        if (ptr->ReadBinary(totalRecordVectorBytes, vecBuf, offset) != totalRecordVectorBytes) {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read VectorSet!\n");
+            throw std::runtime_error("Failed read file");
+        }
+    }
+
+    SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Load Vector(%d,%d)\n", end - start, col);
+    return std::make_shared<BasicVectorSet>(vectorSet,
+                                            m_options->m_inputValueType,
+                                            col,
+                                            end - start);
+}
+
+
+std::shared_ptr<MetadataSet>
+DefaultVectorReader::GetMetadataSet() const
+{
+    if (fileexists(m_metadataIndexOutput.c_str()) && fileexists(m_metadataConentOutput.c_str()))
+        return std::shared_ptr<MetadataSet>(new FileMetadataSet(m_metadataConentOutput, m_metadataIndexOutput));
+    return nullptr;
+}

SPANN/AnnService/src/Helper/VectorSetReaders/TxtReader.cpp

@@ -0,0 +1,436 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/VectorSetReaders/TxtReader.h"
+#include "inc/Helper/StringConvert.h"
+#include "inc/Helper/CommonHelper.h"
+
+#include <omp.h>
+
+using namespace SPTAG;
+using namespace SPTAG::Helper;
+
+TxtVectorReader::TxtVectorReader(std::shared_ptr<ReaderOptions> p_options)
+    : VectorSetReader(p_options),
+    m_subTaskBlocksize(0)
+{
+    omp_set_num_threads(m_options->m_threadNum);
+
+    std::string tempFolder("tempfolder");
+    if (!direxists(tempFolder.c_str()))
+    {
+        mkdir(tempFolder.c_str());
+    }
+
+    tempFolder += FolderSep;
+    std::srand(clock());
+    std::string randstr = std::to_string(std::rand());
+    m_vectorOutput = tempFolder + "vectorset.bin." + randstr;
+    m_metadataConentOutput = tempFolder + "metadata.bin." + randstr;
+    m_metadataIndexOutput = tempFolder + "metadataindex.bin." + randstr;
+}
+
+
+TxtVectorReader::~TxtVectorReader()
+{
+    if (fileexists(m_vectorOutput.c_str()))
+    {
+        remove(m_vectorOutput.c_str());
+    }
+
+    if (fileexists(m_metadataIndexOutput.c_str()))
+    {
+        remove(m_metadataIndexOutput.c_str());
+    }
+
+    if (fileexists(m_metadataConentOutput.c_str()))
+    {
+        remove(m_metadataConentOutput.c_str());
+    }
+}
+
+
+ErrorCode
+TxtVectorReader::LoadFile(const std::string& p_filePaths)
+{
+    const auto& files = GetFileSizes(p_filePaths);
+    std::vector<std::function<ErrorCode()>> subWorks;
+    subWorks.reserve(files.size() * m_options->m_threadNum);
+
+    m_subTaskCount = 0;
+    for (const auto& fileInfo : files)
+    {
+        if (fileInfo.second == (std::numeric_limits<std::size_t>::max)())
+        {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "File %s not exists or can't access.\n", fileInfo.first.c_str());
+            return ErrorCode::FailedOpenFile;
+        }
+
+        std::uint32_t fileTaskCount = 0;
+        std::size_t blockSize = m_subTaskBlocksize;
+        if (0 == blockSize)
+        {
+            fileTaskCount = m_options->m_threadNum;
+            if(fileTaskCount == 0) fileTaskCount = 1;
+            blockSize = (fileInfo.second + fileTaskCount - 1) / fileTaskCount;
+        }
+        else
+        {
+            fileTaskCount = static_cast<std::uint32_t>((fileInfo.second + blockSize - 1) / blockSize);
+        }
+
+        for (std::uint32_t i = 0; i < fileTaskCount; ++i)
+        {
+            subWorks.emplace_back(std::bind(&TxtVectorReader::LoadFileInternal,
+                                            this,
+                                            fileInfo.first,
+                                            m_subTaskCount++,
+                                            i,
+                                            blockSize));
+        }
+    }
+
+    m_totalRecordCount = 0;
+    m_totalRecordVectorBytes = 0;
+    m_subTaskRecordCount.clear();
+    m_subTaskRecordCount.resize(m_subTaskCount, 0);
+
+    m_waitSignal.Reset(m_subTaskCount);
+
+#pragma omp parallel for schedule(dynamic)
+    for (int64_t i = 0; i < (int64_t)subWorks.size(); i++)
+    {
+        ErrorCode code = subWorks[i]();
+        if (ErrorCode::Success != code)
+        {
+            throw std::runtime_error("LoadFileInternal failed");
+        }
+
+    }
+
+    m_waitSignal.Wait();
+
+    return MergeData();
+}
+
+
+std::shared_ptr<VectorSet>
+TxtVectorReader::GetVectorSet(SizeType start, SizeType end) const
+{
+    auto ptr = f_createIO();
+    if (ptr == nullptr || !ptr->Initialize(m_vectorOutput.c_str(), std::ios::binary | std::ios::in)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read file %s.\n", m_vectorOutput.c_str());
+        throw std::runtime_error("Failed to read vectorset file");
+    }
+
+    SizeType row;
+    DimensionType col;
+    if (ptr->ReadBinary(sizeof(SizeType), (char*)&row) != sizeof(SizeType)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read VectorSet!\n");
+        throw std::runtime_error("Failed to read vectorset file");
+    }
+    if (ptr->ReadBinary(sizeof(DimensionType), (char*)&col) != sizeof(DimensionType)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read VectorSet!\n");
+        throw std::runtime_error("Failed to read vectorset file");
+    }
+
+    if (start > row) start = row;
+    if (end < 0 || end > row) end = row;
+    std::uint64_t totalRecordVectorBytes = ((std::uint64_t)GetValueTypeSize(m_options->m_inputValueType)) * (end - start) * col;
+    ByteArray vectorSet;
+    if (totalRecordVectorBytes > 0) {
+        vectorSet = ByteArray::Alloc(totalRecordVectorBytes);
+        char* vecBuf = reinterpret_cast<char*>(vectorSet.Data());
+        std::uint64_t offset = ((std::uint64_t)GetValueTypeSize(m_options->m_inputValueType)) * start * col + +sizeof(SizeType) + sizeof(DimensionType);
+        if (ptr->ReadBinary(totalRecordVectorBytes, vecBuf, offset) != totalRecordVectorBytes) {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read VectorSet!\n");
+            throw std::runtime_error("Failed to read vectorset file");
+        }
+    }
+    return std::shared_ptr<VectorSet>(new BasicVectorSet(vectorSet,
+        m_options->m_inputValueType,
+        col,
+        end - start));
+}
+
+
+std::shared_ptr<MetadataSet>
+TxtVectorReader::GetMetadataSet() const
+{
+    if (fileexists(m_metadataIndexOutput.c_str()) && fileexists(m_metadataConentOutput.c_str()))
+        return std::shared_ptr<MetadataSet>(new FileMetadataSet(m_metadataConentOutput, m_metadataIndexOutput));
+    return nullptr;
+}
+
+
+ErrorCode
+TxtVectorReader::LoadFileInternal(const std::string& p_filePath,
+                                std::uint32_t p_subTaskID,
+                                std::uint32_t p_fileBlockID,
+                                std::size_t p_fileBlockSize)
+{
+    std::uint64_t lineBufferSize = 1 << 16;
+    std::unique_ptr<char[]> currentLine(new char[lineBufferSize]);
+
+    SizeType recordCount = 0;
+    std::uint64_t metaOffset = 0;
+    std::size_t totalRead = 0;
+    std::streamoff startpos = p_fileBlockID * p_fileBlockSize;
+
+    std::shared_ptr<Helper::DiskIO> input = f_createIO(), output = f_createIO(), meta = f_createIO(), metaIndex = f_createIO();
+    if (input == nullptr || !input->Initialize(p_filePath.c_str(), std::ios::in | std::ios::binary))
+    {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to open file: %s\n",p_filePath.c_str());
+        return ErrorCode::FailedOpenFile;
+    }
+
+    SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Begin Subtask: %u, start offset position: %lld\n", p_subTaskID, startpos);
+
+    std::string subFileSuffix("_");
+    subFileSuffix += std::to_string(p_subTaskID);
+    subFileSuffix += ".tmp";
+
+    if (output == nullptr || !output->Initialize((m_vectorOutput + subFileSuffix).c_str(), std::ios::binary | std::ios::out) ||
+        meta == nullptr || !meta->Initialize((m_metadataConentOutput + subFileSuffix).c_str(), std::ios::binary | std::ios::out) ||
+        metaIndex == nullptr || !metaIndex->Initialize((m_metadataIndexOutput + subFileSuffix).c_str(), std::ios::binary | std::ios::out))
+    {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to create files: %s %s %s\n", (m_vectorOutput + subFileSuffix).c_str(), (m_metadataConentOutput + subFileSuffix).c_str(), (m_metadataIndexOutput + subFileSuffix).c_str());
+        return ErrorCode::FailedCreateFile;
+    }
+
+    if (p_fileBlockID != 0)
+    {
+        totalRead += input->ReadString(lineBufferSize, currentLine, '\n', startpos);
+    }
+
+    std::size_t vectorByteSize = GetValueTypeSize(m_options->m_inputValueType) * m_options->m_dimension;
+    std::unique_ptr<std::uint8_t[]> vector;
+    vector.reset(new std::uint8_t[vectorByteSize]);
+
+    while (totalRead <= p_fileBlockSize)
+    {
+        std::uint64_t lineLength = input->ReadString(lineBufferSize, currentLine);
+        if (lineLength == 0) break;
+        totalRead += lineLength;
+
+        std::size_t tabIndex = lineLength - 1;
+        while (tabIndex > 0 && currentLine[tabIndex] != '\t')
+        {
+            --tabIndex;
+        }
+
+        if (0 == tabIndex && currentLine[tabIndex] != '\t')
+        {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Subtask: %u cannot parsing line:%s\n", p_subTaskID, currentLine.get());
+            return ErrorCode::FailedParseValue;
+        }
+
+        bool parseSuccess = false;
+        switch (m_options->m_inputValueType)
+        {
+#define DefineVectorValueType(Name, Type) \
+        case VectorValueType::Name: \
+            parseSuccess = TranslateVector(currentLine.get() + tabIndex + 1, reinterpret_cast<Type*>(vector.get())); \
+            break; \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineVectorValueType
+
+        default:
+            parseSuccess = false;
+            break;
+        }
+
+        if (!parseSuccess)
+        {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Subtask: %u cannot parsing vector:%s\n", p_subTaskID, currentLine.get());
+            return ErrorCode::FailedParseValue;
+        }
+
+        ++recordCount;
+        if (output->WriteBinary(vectorByteSize, (char*)vector.get()) != vectorByteSize ||
+            meta->WriteBinary(tabIndex, currentLine.get()) != tabIndex ||
+            metaIndex->WriteBinary(sizeof(metaOffset), (const char*)&metaOffset) != sizeof(metaOffset)) {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Subtask: %u cannot write line:%s\n", p_subTaskID, currentLine.get());
+            return ErrorCode::DiskIOFail;
+        }
+        metaOffset += tabIndex;
+    }
+    if (metaIndex->WriteBinary(sizeof(metaOffset), (const char*)&metaOffset) != sizeof(metaOffset)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Subtask: %u cannot write final offset!\n", p_subTaskID);
+        return ErrorCode::DiskIOFail;
+    }
+
+    m_totalRecordCount += recordCount;
+    m_subTaskRecordCount[p_subTaskID] = recordCount;
+    m_totalRecordVectorBytes += recordCount * vectorByteSize;
+
+    m_waitSignal.FinishOne();
+    return ErrorCode::Success;
+}
+
+
+ErrorCode
+TxtVectorReader::MergeData()
+{
+    const std::size_t bufferSize = 1 << 30;
+    const std::size_t bufferSizeTrim64 = (bufferSize / sizeof(std::uint64_t)) * sizeof(std::uint64_t);
+
+    std::shared_ptr<Helper::DiskIO> input = f_createIO(), output = f_createIO(), meta = f_createIO(), metaIndex = f_createIO();
+
+    if (output == nullptr || !output->Initialize(m_vectorOutput.c_str(), std::ios::binary | std::ios::out) ||
+        meta == nullptr || !meta->Initialize(m_metadataConentOutput.c_str(), std::ios::binary | std::ios::out) ||
+        metaIndex == nullptr || !metaIndex->Initialize(m_metadataIndexOutput.c_str(), std::ios::binary | std::ios::out))
+    {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to create files: %s %s %s\n", m_vectorOutput.c_str(), m_metadataConentOutput.c_str(), m_metadataIndexOutput.c_str());
+        return ErrorCode::FailedCreateFile;
+    }
+
+    std::unique_ptr<char[]> bufferHolder(new char[bufferSize]);
+    char* buf = bufferHolder.get();
+
+    SizeType totalRecordCount = m_totalRecordCount;
+    if (output->WriteBinary(sizeof(totalRecordCount), (char*)(&totalRecordCount)) != sizeof(totalRecordCount)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to write file: %s\n", m_vectorOutput.c_str());
+        return ErrorCode::DiskIOFail;
+    }
+    if (output->WriteBinary(sizeof(m_options->m_dimension), (char*)&(m_options->m_dimension)) != sizeof(m_options->m_dimension)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to write file: %s\n", m_vectorOutput.c_str());
+        return ErrorCode::DiskIOFail;
+    }
+
+    for (std::uint32_t i = 0; i < m_subTaskCount; ++i)
+    {
+        std::string file = m_vectorOutput;
+        file += "_";
+        file += std::to_string(i);
+        file += ".tmp";
+
+        if (input == nullptr || !input->Initialize(file.c_str(), std::ios::binary | std::ios::in))
+        {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to open file: %s\n", file.c_str());
+            return ErrorCode::FailedOpenFile;
+        }
+
+        std::uint64_t readSize = input->ReadBinary(bufferSize, bufferHolder.get());
+        while (readSize != 0) {            
+            if (output->WriteBinary(readSize, bufferHolder.get()) != readSize) {
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to write file: %s\n", m_vectorOutput.c_str());
+                return ErrorCode::DiskIOFail;
+            }
+            readSize = input->ReadBinary(bufferSize, bufferHolder.get());
+        }
+        input->ShutDown();
+        remove(file.c_str());
+    }
+
+    for (std::uint32_t i = 0; i < m_subTaskCount; ++i)
+    {
+        std::string file = m_metadataConentOutput;
+        file += "_";
+        file += std::to_string(i);
+        file += ".tmp";
+
+        if (input == nullptr || !input->Initialize(file.c_str(), std::ios::binary | std::ios::in))
+        {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to open file: %s\n", file.c_str());
+            return ErrorCode::FailedOpenFile;
+        }
+
+        std::uint64_t readSize = input->ReadBinary(bufferSize, bufferHolder.get());
+        while ( readSize != 0 ) {
+            if (meta->WriteBinary(readSize, bufferHolder.get()) != readSize) {
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to write file: %s\n", m_metadataConentOutput.c_str());
+                return ErrorCode::DiskIOFail;
+            }
+            readSize = input->ReadBinary(bufferSize, bufferHolder.get());
+        }
+        input->ShutDown();
+        remove(file.c_str());
+    }
+
+    if (metaIndex->WriteBinary(sizeof(totalRecordCount), (char*)(&totalRecordCount)) != sizeof(totalRecordCount)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to write file: %s\n", m_metadataIndexOutput.c_str());
+        return ErrorCode::DiskIOFail;
+    }
+
+    std::uint64_t totalOffset = 0;
+    for (std::uint32_t i = 0; i < m_subTaskCount; ++i)
+    {
+        std::string file = m_metadataIndexOutput;
+        file += "_";
+        file += std::to_string(i);
+        file += ".tmp";
+
+        if (input == nullptr || !input->Initialize(file.c_str(), std::ios::binary | std::ios::in))
+        {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to open file: %s\n", file.c_str());
+            return ErrorCode::FailedOpenFile;
+        }
+
+        for (SizeType remains = m_subTaskRecordCount[i]; remains > 0;)
+        {
+            std::size_t readBytesCount = min(remains * sizeof(std::uint64_t), bufferSizeTrim64);
+            if (input->ReadBinary(readBytesCount, buf) != readBytesCount) {
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to read file: %s\n", file.c_str());
+                return ErrorCode::DiskIOFail;
+            }
+            std::uint64_t* offset = reinterpret_cast<std::uint64_t*>(buf);
+            for (std::uint64_t j = 0; j < readBytesCount / sizeof(std::uint64_t); ++j)
+            {
+                offset[j] += totalOffset;
+            }
+
+            if (metaIndex->WriteBinary(readBytesCount, buf) != readBytesCount) {
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to write file: %s\n", m_metadataIndexOutput.c_str());
+                return ErrorCode::DiskIOFail;
+            }
+            remains -= static_cast<SizeType>(readBytesCount / sizeof(std::uint64_t));
+        }
+        if (input->ReadBinary(sizeof(std::uint64_t), buf) != sizeof(std::uint64_t)) {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to read file: %s\n", file.c_str());
+            return ErrorCode::DiskIOFail;
+        }
+        totalOffset += *(reinterpret_cast<std::uint64_t*>(buf));
+
+        input->ShutDown();
+        remove(file.c_str());
+    }
+
+    if (metaIndex->WriteBinary(sizeof(totalOffset), (char*)&totalOffset) != sizeof(totalOffset)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Unable to write file: %s\n", m_metadataIndexOutput.c_str());
+        return ErrorCode::DiskIOFail;
+    }
+    return ErrorCode::Success;
+}
+
+
+std::vector<TxtVectorReader::FileInfoPair>
+TxtVectorReader::GetFileSizes(const std::string& p_filePaths)
+{
+    const auto& files = Helper::StrUtils::SplitString(p_filePaths, ",");
+    std::vector<TxtVectorReader::FileInfoPair> res;
+    res.reserve(files.size());
+
+    for (const auto& filePath : files)
+    {
+        if (!fileexists(filePath.c_str()))
+        {
+            res.emplace_back(filePath, (std::numeric_limits<std::size_t>::max)());
+            continue;
+        }
+#ifndef _MSC_VER
+        struct stat stat_buf;
+        stat(filePath.c_str(), &stat_buf);
+#else
+        struct _stat64 stat_buf;
+        _stat64(filePath.c_str(), &stat_buf);
+#endif
+        std::size_t fileSize = stat_buf.st_size;
+        res.emplace_back(filePath, static_cast<std::size_t>(fileSize));
+    }
+
+    return res;
+}
+
+

SPANN/AnnService/src/Helper/VectorSetReaders/XvecReader.cpp

@@ -0,0 +1,119 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/VectorSetReaders/XvecReader.h"
+#include "inc/Helper/CommonHelper.h"
+
+#include <time.h>
+
+using namespace SPTAG;
+using namespace SPTAG::Helper;
+
+XvecVectorReader::XvecVectorReader(std::shared_ptr<ReaderOptions> p_options)
+    : VectorSetReader(p_options)
+{
+    std::string tempFolder("tempfolder");
+    if (!direxists(tempFolder.c_str()))
+    {
+        mkdir(tempFolder.c_str());
+    }
+    std::srand(clock());
+    m_vectorOutput = tempFolder + FolderSep + "vectorset.bin." + std::to_string(std::rand());
+}
+
+
+XvecVectorReader::~XvecVectorReader()
+{
+    if (fileexists(m_vectorOutput.c_str()))
+    {
+        remove(m_vectorOutput.c_str());
+    }
+}
+
+
+ErrorCode
+XvecVectorReader::LoadFile(const std::string& p_filePaths)
+{
+    const auto& files = Helper::StrUtils::SplitString(p_filePaths, ",");
+    auto fp = f_createIO();
+    if (fp == nullptr || !fp->Initialize(m_vectorOutput.c_str(), std::ios::binary | std::ios::out)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to write file: %s \n", m_vectorOutput.c_str());
+        return ErrorCode::FailedCreateFile;
+    }
+    SizeType vectorCount = 0;
+    IOBINARY(fp, WriteBinary, sizeof(vectorCount), (char*)&vectorCount);
+    IOBINARY(fp, WriteBinary, sizeof(m_options->m_dimension), (char*)&(m_options->m_dimension));
+    
+    size_t vectorDataSize = GetValueTypeSize(m_options->m_inputValueType) * m_options->m_dimension;
+    std::unique_ptr<char[]> buffer(new char[vectorDataSize]);
+    for (std::string file : files)
+    {
+        auto ptr = f_createIO();
+        if (ptr == nullptr || !ptr->Initialize(file.c_str(), std::ios::binary | std::ios::in)) {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read file: %s \n", file.c_str());
+            return ErrorCode::FailedOpenFile;
+        }
+        while (true)
+        {
+            DimensionType dim;
+            if (ptr->ReadBinary(sizeof(DimensionType), (char*)&dim) == 0) break;
+
+            if (dim != m_options->m_dimension) {
+                SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Xvec file %s has No.%d vector whose dims are not as many as expected. Expected: %d, Fact: %d\n", file.c_str(), vectorCount, m_options->m_dimension, dim);
+                return ErrorCode::DimensionSizeMismatch;
+            }
+            IOBINARY(ptr, ReadBinary, vectorDataSize, buffer.get());
+            IOBINARY(fp, WriteBinary, vectorDataSize, buffer.get());
+            vectorCount++;
+        }
+    }
+    IOBINARY(fp, WriteBinary, sizeof(vectorCount), (char*)&vectorCount, 0);
+    return ErrorCode::Success;
+}
+
+
+std::shared_ptr<VectorSet>
+XvecVectorReader::GetVectorSet(SizeType start, SizeType end) const
+{
+    auto ptr = f_createIO();
+    if (ptr == nullptr || !ptr->Initialize(m_vectorOutput.c_str(), std::ios::binary | std::ios::in)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read file %s.\n", m_vectorOutput.c_str());
+        throw std::runtime_error("Failed read file");
+    }
+
+    SizeType row;
+    DimensionType col;
+    if (ptr->ReadBinary(sizeof(SizeType), (char*)&row) != sizeof(SizeType)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read VectorSet!\n");
+        throw std::runtime_error("Failed read file");
+    }
+    if (ptr->ReadBinary(sizeof(DimensionType), (char*)&col) != sizeof(DimensionType)) {
+        SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read VectorSet!\n");
+        throw std::runtime_error("Failed read file");
+    }
+
+    if (start > row) start = row;
+    if (end < 0 || end > row) end = row;
+    std::uint64_t totalRecordVectorBytes = ((std::uint64_t)GetValueTypeSize(m_options->m_inputValueType)) * (end - start) * col;
+    ByteArray vectorSet;
+    if (totalRecordVectorBytes > 0) {
+        vectorSet = ByteArray::Alloc(totalRecordVectorBytes);
+        char* vecBuf = reinterpret_cast<char*>(vectorSet.Data());
+        std::uint64_t offset = ((std::uint64_t)GetValueTypeSize(m_options->m_inputValueType)) * start * col + +sizeof(SizeType) + sizeof(DimensionType);
+        if (ptr->ReadBinary(totalRecordVectorBytes, vecBuf, offset) != totalRecordVectorBytes) {
+            SPTAGLIB_LOG(Helper::LogLevel::LL_Error, "Failed to read VectorSet!\n");
+            throw std::runtime_error("Failed read file");
+        }
+    }
+    return std::shared_ptr<VectorSet>(new BasicVectorSet(vectorSet,
+        m_options->m_inputValueType,
+        col,
+        end - start));
+}
+
+
+std::shared_ptr<MetadataSet>
+XvecVectorReader::GetMetadataSet() const
+{
+    return nullptr;
+}

SPANN/ThirdParty/zstd/.circleci/config.yml

@@ -0,0 +1,124 @@
+version: 2
+
+jobs:
+  # the first half of the jobs are in this test
+  short-tests-0:
+    # TODO: Create a small custom docker image with all the dependencies we need
+    #       preinstalled to reduce installation time.
+    docker:
+      - image: fbopensource/zstd-circleci-primary:0.0.1
+    # TODO: Re-enable aarch64 build:
+    #       make aarch64build     && make clean
+    steps:
+      - checkout
+      - run:
+          name: Test
+          command: |
+            ./tests/test-license.py
+            cc -v
+            CFLAGS="-O0 -Werror -pedantic" make allmost; make clean
+            make c99build; make clean
+            make c11build; make clean
+            make -j regressiontest; make clean
+            make shortest; make clean
+            make cxxtest; make clean
+  # the second half of the jobs are in this test
+  short-tests-1:
+    docker:
+      - image: fbopensource/zstd-circleci-primary:0.0.1
+    steps:
+      - checkout
+      - run:
+          name: Test
+          command: |
+            make gnu90build; make clean
+            make gnu99build; make clean
+            make ppc64build V=1; make clean
+            make ppcbuild   V=1; make clean
+            make armbuild   V=1; make clean
+            make -C tests test-legacy test-longmatch; make clean
+            make -C lib libzstd-nomt; make clean
+  # This step should only be run in a cron job
+  regression-test:
+    docker:
+      - image: fbopensource/zstd-circleci-primary:0.0.1
+    environment:
+      CIRCLE_ARTIFACTS: /tmp/circleci-artifacts
+    steps:
+      - checkout
+      # Restore the cached resources.
+      - restore_cache:
+          # We try our best to bust the cache when the data changes by hashing
+          # data.c. If that doesn't work, simply update the version number here
+          # and below. If we fail to bust the cache, the regression testing will
+          # still work, since it has its own stamp, but will need to redownload
+          # everything.
+          keys:
+            - regression-cache-{{ checksum "tests/regression/data.c" }}-v0
+      - run:
+          name: Regression Test
+          command: |
+            make -C programs zstd
+            make -C tests/regression test
+            mkdir -p $CIRCLE_ARTIFACTS
+            ./tests/regression/test                     \
+                --cache  tests/regression/cache         \
+                --output $CIRCLE_ARTIFACTS/results.csv  \
+                --zstd   programs/zstd
+            echo "NOTE: The new results.csv is uploaded as an artifact to this job"
+            echo "      If this fails, go to the Artifacts pane in CircleCI, "
+            echo "      download /tmp/circleci-artifacts/results.csv, and if they "
+            echo "      are still good, copy it into the repo and commit it."
+            echo "> diff tests/regression/results.csv $CIRCLE_ARTIFACTS/results.csv"
+            diff tests/regression/results.csv $CIRCLE_ARTIFACTS/results.csv
+      # Only save the cache on success (default), since if the failure happened
+      # before we stamp the data cache, we will have a bad cache for this key.
+      - save_cache:
+          key: regression-cache-{{ checksum "tests/regression/data.c" }}-v0
+          paths:
+            - tests/regression/cache
+      - store_artifacts:
+          path: /tmp/circleci-artifacts
+
+
+workflows:
+  version: 2
+  commit:
+    jobs:
+      # Run the tests in parallel
+      - short-tests-0
+      - short-tests-1
+      - regression-test
+
+  nightly:
+    triggers:
+      - schedule:
+          cron: "0 0 * * *"
+          filters:
+            branches:
+              only:
+                - release
+                - dev
+                - master
+    jobs:
+      # Run daily regression tests
+      - regression-test
+
+
+
+  # Longer tests
+    #- make -C tests test-zstd-nolegacy && make clean
+    #- pyenv global 3.4.4; make -C tests versionsTest && make clean
+    #- make zlibwrapper         && make clean
+    #- gcc -v; make -C tests test32 MOREFLAGS="-I/usr/include/x86_64-linux-gnu" && make clean
+    #- make uasan               && make clean
+    #- make asan32              && make clean
+    #- make -C tests test32 CC=clang MOREFLAGS="-g -fsanitize=address -I/usr/include/x86_64-linux-gnu"
+  # Valgrind tests
+    #- CFLAGS="-O1 -g" make -C zlibWrapper valgrindTest && make clean
+    #- make -C tests valgrindTest && make clean
+  # ARM, AArch64, PowerPC, PowerPC64 tests
+    #- make ppctest             && make clean
+    #- make ppc64test           && make clean
+    #- make armtest             && make clean
+    #- make aarch64test         && make clean

SPANN/ThirdParty/zstd/.circleci/images/primary/Dockerfile

@@ -0,0 +1,9 @@
+FROM circleci/buildpack-deps:bionic
+
+RUN sudo dpkg --add-architecture i386
+RUN sudo apt-get -y -qq update
+RUN sudo apt-get -y install \
+    gcc-multilib-powerpc-linux-gnu gcc-arm-linux-gnueabi \
+    libc6-dev-armel-cross gcc-aarch64-linux-gnu libc6-dev-arm64-cross \
+    libc6-dev-ppc64-powerpc-cross zstd gzip coreutils \
+    libcurl4-openssl-dev

SPANN/ThirdParty/zstd/.cirrus.yml

@@ -0,0 +1,11 @@
+task:
+  name: FreeBSD (shortest)
+  freebsd_instance:
+    matrix:
+      image_family: freebsd-12-2
+      # The stable 11.3 image causes "Agent is not responding" so use a snapshot
+      image_family: freebsd-11-3-snap
+  install_script: pkg install -y gmake coreutils
+  script: |
+    MOREFLAGS="-Werror" gmake -j all
+    gmake shortest

SPANN/ThirdParty/zstd/.gitattributes

@@ -0,0 +1,21 @@
+# Set the default behavior
+* text eol=lf
+
+# Explicitly declare source files
+*.c text eol=lf
+*.h text eol=lf
+
+# Denote files that should not be modified.
+*.odt binary
+*.png binary
+
+# Visual Studio
+*.sln text eol=crlf
+*.vcxproj* text eol=crlf
+*.vcproj* text eol=crlf
+*.suo binary
+*.rc text eol=crlf
+
+# Windows
+*.bat text eol=crlf
+*.cmd text eol=crlf

SPANN/ThirdParty/zstd/.gitignore

@@ -0,0 +1,55 @@
+# Object files
+*.o
+*.ko
+*.dSYM
+
+# Libraries
+*.lib
+*.a
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+/zstd
+zstdmt
+*.exe
+*.out
+*.app
+
+# Test artefacts
+tmp*
+*.zst
+*.zstd
+dictionary.
+dictionary
+NUL
+
+# Build artefacts
+contrib/linux-kernel/linux/
+projects/
+bin/
+.buckd/
+buck-out/
+build-*
+*.gcda
+
+# Other files
+.directory
+_codelite/
+_zstdbench/
+.clang_complete
+*.idea
+*.swp
+.DS_Store
+googletest/
+*.d
+*.vscode
+*.code-workspace
+compile_commands.json
+.clangd
+perf.data
+perf.data.old

SPANN/ThirdParty/zstd/.travis.yml

@@ -0,0 +1,128 @@
+# Travis CI is used to test platforms that github-actions currently doesn't support
+# without either self-hosting or some finnicky work-around. Also, some tests
+# are troublesome to migrate since GH Actions runs tests not in a tty.
+language: c
+
+git:
+  depth: 1
+
+branches:
+  only:
+  - dev
+  - release
+  - master
+  - travisTest
+
+addons:
+  apt:
+    update: true
+
+env:
+  global:
+    - FUZZERTEST=-T1mn
+      ZSTREAM_TESTTIME=-T1mn
+      DECODECORPUS_TESTTIME=-T1mn
+
+matrix:
+  fast_finish: true
+  include:
+    - name: S390X (big endian) + Fuzz test
+      dist: trusty
+      arch: s390x
+      script:
+        - FUZZER_FLAGS=--no-big-tests make -C tests fuzztest
+
+    - name: S390X (big endian) + Fuzz test + no intrinsics
+      dist: trusty
+      arch: s390x
+      script:
+        - MOREFLAGS="-DZSTD_NO_INTRINSICS" FUZZER_FLAGS=--no-big-tests make -C tests fuzztest
+
+    - name: arm64    # ~2.5 mn
+      os: linux
+      arch: arm64
+      script:
+        - make check
+
+    - name: arm64fuzz
+      os: linux
+      arch: arm64
+      script:
+        - make -C tests fuzztest
+
+    # TODO: migrate to GH Actions once newest clang staticanalyze warnings are fixed
+    - name: static analyzer scanbuild    # ~8mn
+      dist: trusty  # note : it's important to pin down a version of static analyzer, since different versions report different false positives
+      script:
+        - make staticAnalyze
+
+    # GH actions can't run this command on OS-X, non-tty issues
+    - name: OS-X make all lib
+      os: osx
+      script:
+        - make -C lib all
+
+    # Introduced to check compat with old toolchains, to prevent e.g. #1872
+    - name: ARM Build Test (on Trusty)
+      dist: trusty
+      script:
+        - make arminstall
+        - make armbuild
+
+    # check release number (release/new tag only)
+    - name: Tag-Specific Test
+      if: tag =~ ^v[0-9]\.[0-9]
+      script:
+        - make -C tests checkTag
+        - tests/checkTag "$TRAVIS_BRANCH"
+
+    - name: PPC64LE + Fuzz test  # ~13mn
+      arch: ppc64le
+      env:
+        - FUZZER_FLAGS=--no-big-tests
+        - MOREFLAGS="-static"
+      script:
+        - cat /proc/cpuinfo
+        - make -C tests fuzztest
+
+    # This test currently fails on GA specifically, for no obvious reason
+    # (it works fine on travisCI, and on local test platforms).
+    - name: Versions Compatibility Test   # ~6mn
+      script:
+        - make -C tests versionsTest
+
+    # meson dedicated test
+    - name: Xenial (Meson + clang)    # ~15mn
+      dist: bionic
+      language: cpp
+      compiler: clang
+      install:
+        - sudo apt-get install -qq liblz4-dev valgrind tree
+        - |
+          travis_retry curl -o ~/ninja.zip -L 'https://github.com/ninja-build/ninja/releases/download/v1.9.0/ninja-linux.zip' &&
+          unzip ~/ninja.zip -d ~/.local/bin
+        - |
+          travis_retry curl -o ~/get-pip.py -L 'https://bootstrap.pypa.io/get-pip.py' &&
+          python3 ~/get-pip.py --user &&
+          pip3 install --user meson
+      script:
+        - |
+          meson setup \
+            --buildtype=debugoptimized \
+            -Db_lundef=false \
+            -Dauto_features=enabled \
+            -Dbin_programs=true \
+            -Dbin_tests=true \
+            -Dbin_contrib=true \
+            -Ddefault_library=both \
+             build/meson builddir
+        - pushd builddir
+        - ninja
+        - meson test --verbose --no-rebuild
+        - DESTDIR=./staging ninja install
+        - tree ./staging
+      after_failure:
+        - cat "$TRAVIS_BUILD_DIR"/builddir/meson-logs/testlog.txt
+
+  allow_failures:
+    - env: ALLOW_FAILURES=true

SPANN/ThirdParty/zstd/CONTRIBUTING.md

@@ -0,0 +1,489 @@
+# Contributing to Zstandard
+We want to make contributing to this project as easy and transparent as
+possible.
+
+## Our Development Process
+New versions are being developed in the "dev" branch,
+or in their own feature branch.
+When they are deemed ready for a release, they are merged into "release".
+
+As a consequences, all contributions must stage first through "dev"
+or their own feature branch.
+
+## Pull Requests
+We actively welcome your pull requests.
+
+1. Fork the repo and create your branch from `dev`.
+2. If you've added code that should be tested, add tests.
+3. If you've changed APIs, update the documentation.
+4. Ensure the test suite passes.
+5. Make sure your code lints.
+6. If you haven't already, complete the Contributor License Agreement ("CLA").
+
+## Contributor License Agreement ("CLA")
+In order to accept your pull request, we need you to submit a CLA. You only need
+to do this once to work on any of Facebook's open source projects.
+
+Complete your CLA here: <https://code.facebook.com/cla>
+
+## Workflow
+Zstd uses a branch-based workflow for making changes to the codebase. Typically, zstd
+will use a new branch per sizable topic. For smaller changes, it is okay to lump multiple
+related changes into a branch.
+
+Our contribution process works in three main stages:
+1. Local development
+    * Update:
+        * Checkout your fork of zstd if you have not already
+        ```
+        git checkout https://github.com/<username>/zstd
+        cd zstd
+        ```
+        * Update your local dev branch
+        ```
+        git pull https://github.com/facebook/zstd dev
+        git push origin dev
+        ```
+    * Topic and development:
+        * Make a new branch on your fork about the topic you're developing for
+        ```
+        # branch names should be concise but sufficiently informative
+        git checkout -b <branch-name>
+        git push origin <branch-name>
+        ```
+        * Make commits and push
+        ```
+        # make some changes =
+        git add -u && git commit -m <message>
+        git push origin <branch-name>
+        ```
+        * Note: run local tests to ensure that your changes didn't break existing functionality
+            * Quick check
+            ```
+            make shortest
+            ```
+            * Longer check
+            ```
+            make test
+            ```
+2. Code Review and CI tests
+    * Ensure CI tests pass:
+        * Before sharing anything to the community, create a pull request in your own fork against the dev branch
+        and make sure that all GitHub Actions CI tests pass. See the Continuous Integration section below for more information.
+        * Ensure that static analysis passes on your development machine. See the Static Analysis section
+        below to see how to do this.
+    * Create a pull request:
+        * When you are ready to share you changes to the community, create a pull request from your branch
+        to facebook:dev. You can do this very easily by clicking 'Create Pull Request' on your fork's home
+        page.
+        * From there, select the branch where you made changes as your source branch and facebook:dev
+        as the destination.
+        * Examine the diff presented between the two branches to make sure there is nothing unexpected.
+    * Write a good pull request description:
+        * While there is no strict template that our contributors follow, we would like them to
+        sufficiently summarize and motivate the changes they are proposing. We recommend all pull requests,
+        at least indirectly, address the following points.
+            * Is this pull request important and why?
+            * Is it addressing an issue? If so, what issue? (provide links for convenience please)
+            * Is this a new feature? If so, why is it useful and/or necessary?
+            * Are there background references and documents that reviewers should be aware of to properly assess this change?
+        * Note: make sure to point out any design and architectural decisions that you made and the rationale behind them.
+        * Note: if you have been working with a specific user and would like them to review your work, make sure you mention them using (@<username>)
+    * Submit the pull request and iterate with feedback.
+3. Merge and Release
+    * Getting approval:
+        * You will have to iterate on your changes with feedback from other collaborators to reach a point
+        where your pull request can be safely merged.
+        * To avoid too many comments on style and convention, make sure that you have a
+        look at our style section below before creating a pull request.
+        * Eventually, someone from the zstd team will approve your pull request and not long after merge it into
+        the dev branch.
+    * Housekeeping:
+        * Most PRs are linked with one or more Github issues. If this is the case for your PR, make sure
+        the corresponding issue is mentioned. If your change 'fixes' or completely addresses the
+        issue at hand, then please indicate this by requesting that an issue be closed by commenting.
+        * Just because your changes have been merged does not mean the topic or larger issue is complete. Remember
+        that the change must make it to an official zstd release for it to be meaningful. We recommend
+        that contributors track the activity on their pull request and corresponding issue(s) page(s) until
+        their change makes it to the next release of zstd. Users will often discover bugs in your code or
+        suggest ways to refine and improve your initial changes even after the pull request is merged.
+
+## Static Analysis
+Static analysis is a process for examining the correctness or validity of a program without actually
+executing it. It usually helps us find many simple bugs. Zstd uses clang's `scan-build` tool for
+static analysis. You can install it by following the instructions for your OS on https://clang-analyzer.llvm.org/scan-build.
+
+Once installed, you can ensure that our static analysis tests pass on your local development machine
+by running:
+```
+make staticAnalyze
+```
+
+In general, you can use `scan-build` to static analyze any build script. For example, to static analyze
+just `contrib/largeNbDicts` and nothing else, you can run:
+
+```
+scan-build make -C contrib/largeNbDicts largeNbDicts
+```
+
+### Pitfalls of static analysis
+`scan-build` is part of our regular CI suite. Other static analyzers are not.
+
+It can be useful to look at additional static analyzers once in a while (and we do), but it's not a good idea to multiply the nb of analyzers run continuously at each commit and PR. The reasons are :
+
+- Static analyzers are full of false positive. The signal to noise ratio is actually pretty low.
+- A good CI policy is "zero-warning tolerance". That means that all issues must be solved, including false positives. This quickly becomes a tedious workload.
+- Multiple static analyzers will feature multiple kind of false positives, sometimes applying to the same code but in different ways leading to :
+   + torteous code, trying to please multiple constraints, hurting readability and therefore maintenance. Sometimes, such complexity introduce other more subtle bugs, that are just out of scope of the analyzers.
+   + sometimes, these constraints are mutually exclusive : if one try to solve one, the other static analyzer will complain, they can't be both happy at the same time.
+- As if that was not enough, the list of false positives change with each version. It's hard enough to follow one static analyzer, but multiple ones with their own update agenda, this quickly becomes a massive velocity reducer.
+
+This is different from running a static analyzer once in a while, looking at the output, and __cherry picking__ a few warnings that seem helpful, either because they detected a genuine risk of bug, or because it helps expressing the code in a way which is more readable or more difficult to misuse. These kind of reports can be useful, and are accepted.
+
+## Continuous Integration
+CI tests run every time a pull request (PR) is created or updated. The exact tests
+that get run will depend on the destination branch you specify. Some tests take
+longer to run than others. Currently, our CI is set up to run a short
+series of tests when creating a PR to the dev branch and a longer series of tests
+when creating a PR to the release branch. You can look in the configuration files
+of the respective CI platform for more information on what gets run when.
+
+Most people will just want to create a PR with the destination set to their local dev
+branch of zstd. You can then find the status of the tests on the PR's page. You can also
+re-run tests and cancel running tests from the PR page or from the respective CI's dashboard.
+
+Almost all of zstd's CI runs on GitHub Actions (configured at `.github/workflows`), which will automatically run on PRs to your
+own fork. A small number of tests run on other services (e.g. Travis CI, Circle CI, Appveyor).
+These require work to set up on your local fork, and (at least for Travis CI) cost money.
+Therefore, if the PR on your local fork passes GitHub Actions, feel free to submit a PR
+against the main repo.
+
+### Third-party CI
+A small number of tests cannot run on GitHub Actions, or have yet to be migrated.
+For these, we use a variety of third-party services (listed below). It is not necessary to set
+these up on your fork in order to contribute to zstd; however, we do link to instructions for those
+who want earlier signal.
+
+| Service   | Purpose                                                                                                    | Setup Links                                                                                                                                            | Config Path            |
+|-----------|------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------|
+| Travis CI | Used for testing on non-x86 architectures such as PowerPC                                                  | https://docs.travis-ci.com/user/tutorial/#to-get-started-with-travis-ci-using-github <br> https://github.com/marketplace/travis-ci                     | `.travis.yml`          |
+| AppVeyor  | Used for some Windows testing (e.g. cygwin, mingw)                                                         | https://www.appveyor.com/blog/2018/10/02/github-apps-integration/ <br> https://github.com/marketplace/appveyor                                         | `appveyor.yml`         |
+| Cirrus CI | Used for testing on FreeBSD                                                                                | https://github.com/marketplace/cirrus-ci/                                                                                                              | `.cirrus.yml`          |
+| Circle CI | Historically was used to provide faster signal,<br/> but we may be able to migrate these to Github Actions | https://circleci.com/docs/2.0/getting-started/#setting-up-circleci <br> https://youtu.be/Js3hMUsSZ2c <br> https://circleci.com/docs/2.0/enable-checks/ | `.circleci/config.yml` |
+
+Note: the instructions linked above mostly cover how to set up a repository with CI from scratch. 
+The general idea should be the same for setting up CI on your fork of zstd, but you may have to 
+follow slightly different steps. In particular, please ignore any instructions related to setting up
+config files (since zstd already has configs for each of these services).
+
+## Performance
+Performance is extremely important for zstd and we only merge pull requests whose performance
+landscape and corresponding trade-offs have been adequately analyzed, reproduced, and presented.
+This high bar for performance means that every PR which has the potential to
+impact performance takes a very long time for us to properly review. That being said, we
+always welcome contributions to improve performance (or worsen performance for the trade-off of
+something else). Please keep the following in mind before submitting a performance related PR:
+
+1. Zstd isn't as old as gzip but it has been around for time now and its evolution is
+very well documented via past Github issues and pull requests. It may be the case that your
+particular performance optimization has already been considered in the past. Please take some
+time to search through old issues and pull requests using keywords specific to your
+would-be PR. Of course, just because a topic has already been discussed (and perhaps rejected
+on some grounds) in the past, doesn't mean it isn't worth bringing up again. But even in that case,
+it will be helpful for you to have context from that topic's history before contributing.
+2. The distinction between noise and actual performance gains can unfortunately be very subtle
+especially when microbenchmarking extremely small wins or losses. The only remedy to getting
+something subtle merged is extensive benchmarking. You will be doing us a great favor if you
+take the time to run extensive, long-duration, and potentially cross-(os, platform, process, etc)
+benchmarks on your end before submitting a PR. Of course, you will not be able to benchmark
+your changes on every single processor and os out there (and neither will we) but do that best
+you can:) We've adding some things to think about when benchmarking below in the Benchmarking
+Performance section which might be helpful for you.
+3. Optimizing performance for a certain OS, processor vendor, compiler, or network system is a perfectly
+legitimate thing to do as long as it does not harm the overall performance health of Zstd.
+This is a hard balance to strike but please keep in mind other aspects of Zstd when
+submitting changes that are clang-specific, windows-specific, etc.
+
+## Benchmarking Performance
+Performance microbenchmarking is a tricky subject but also essential for Zstd. We value empirical
+testing over theoretical speculation. This guide it not perfect but for most scenarios, it
+is a good place to start.
+
+### Stability
+Unfortunately, the most important aspect in being able to benchmark reliably is to have a stable
+benchmarking machine. A virtual machine, a machine with shared resources, or your laptop
+will typically not be stable enough to obtain reliable benchmark results. If you can get your
+hands on a desktop, this is usually a better scenario.
+
+Of course, benchmarking can be done on non-hyper-stable machines as well. You will just have to
+do a little more work to ensure that you are in fact measuring the changes you've made not and
+noise. Here are some things you can do to make your benchmarks more stable:
+
+1. The most simple thing you can do to drastically improve the stability of your benchmark is
+to run it multiple times and then aggregate the results of those runs. As a general rule of
+thumb, the smaller the change you are trying to measure, the more samples of benchmark runs
+you will have to aggregate over to get reliable results. Here are some additional things to keep in
+mind when running multiple trials:
+    * How you aggregate your samples are important. You might be tempted to use the mean of your
+    results. While this is certainly going to be a more stable number than a raw single sample
+    benchmark number, you might have more luck by taking the median. The mean is not robust to
+    outliers whereas the median is. Better still, you could simply take the fastest speed your
+    benchmark achieved on each run since that is likely the fastest your process will be
+    capable of running your code. In our experience, this (aggregating by just taking the sample
+    with the fastest running time) has been the most stable approach.
+    * The more samples you have, the more stable your benchmarks should be. You can verify
+    your improved stability by looking at the size of your confidence intervals as you
+    increase your sample count. These should get smaller and smaller. Eventually hopefully
+    smaller than the performance win you are expecting.
+    * Most processors will take some time to get `hot` when running anything. The observations
+    you collect during that time period will very different from the true performance number. Having
+    a very large number of sample will help alleviate this problem slightly but you can also
+    address is directly by simply not including the first `n` iterations of your benchmark in
+    your aggregations. You can determine `n` by simply looking at the results from each iteration
+    and then hand picking a good threshold after which the variance in results seems to stabilize.
+2. You cannot really get reliable benchmarks if your host machine is simultaneously running
+another cpu/memory-intensive application in the background. If you are running benchmarks on your
+personal laptop for instance, you should close all applications (including your code editor and
+browser) before running your benchmarks. You might also have invisible background applications
+running. You can see what these are by looking at either Activity Monitor on Mac or Task Manager
+on Windows. You will get more stable benchmark results of you end those processes as well.
+    * If you have multiple cores, you can even run your benchmark on a reserved core to prevent
+    pollution from other OS and user processes. There are a number of ways to do this depending
+    on your OS:
+        * On linux boxes, you have use https://github.com/lpechacek/cpuset.
+        * On Windows, you can "Set Processor Affinity" using https://www.thewindowsclub.com/processor-affinity-windows
+        * On Mac, you can try to use their dedicated affinity API https://developer.apple.com/library/archive/releasenotes/Performance/RN-AffinityAPI/#//apple_ref/doc/uid/TP40006635-CH1-DontLinkElementID_2
+3. To benchmark, you will likely end up writing a separate c/c++ program that will link libzstd.
+Dynamically linking your library will introduce some added variation (not a large amount but
+definitely some). Statically linking libzstd will be more stable. Static libraries should
+be enabled by default when building zstd.
+4. Use a profiler with a good high resolution timer. See the section below on profiling for
+details on this.
+5. Disable frequency scaling, turbo boost and address space randomization (this will vary by OS)
+6. Try to avoid storage. On some systems you can use tmpfs. Putting the program, inputs and outputs on
+tmpfs avoids touching a real storage system, which can have a pretty big variability.
+
+Also check our LLVM's guide on benchmarking here: https://llvm.org/docs/Benchmarking.html
+
+### Zstd benchmark
+The fastest signal you can get regarding your performance changes is via the in-build zstd cli
+bench option. You can run Zstd as you typically would for your scenario using some set of options
+and then additionally also specify the `-b#` option. Doing this will run our benchmarking pipeline
+for that options you have just provided. If you want to look at the internals of how this
+benchmarking script works, you can check out programs/benchzstd.c
+
+For example: say you have made a change that you believe improves the speed of zstd level 1. The
+very first thing you should use to asses whether you actually achieved any sort of improvement
+is `zstd -b`. You might try to do something like this. Note: you can use the `-i` option to
+specify a running time for your benchmark in seconds (default is 3 seconds).
+Usually, the longer the running time, the more stable your results will be.
+
+```
+$ git checkout <commit-before-your-change>
+$ make && cp zstd zstd-old
+$ git checkout <commit-after-your-change>
+$ make && cp zstd zstd-new
+$ zstd-old -i5 -b1 <your-test-data>
+ 1<your-test-data>         :      8990 ->      3992 (2.252), 302.6 MB/s , 626.4 MB/s
+$ zstd-new -i5 -b1 <your-test-data>
+ 1<your-test-data>         :      8990 ->      3992 (2.252), 302.8 MB/s , 628.4 MB/s
+```
+
+Unless your performance win is large enough to be visible despite the intrinsic noise
+on your computer, benchzstd alone will likely not be enough to validate the impact of your
+changes. For example, the results of the example above indicate that effectively nothing
+changed but there could be a small <3% improvement that the noise on the host machine
+obscured. So unless you see a large performance win (10-15% consistently) using just
+this method of evaluation will not be sufficient.
+
+### Profiling
+There are a number of great profilers out there. We're going to briefly mention how you can
+profile your code using `instruments` on mac, `perf` on linux and `visual studio profiler`
+on windows.
+
+Say you have an idea for a change that you think will provide some good performance gains
+for level 1 compression on Zstd. Typically this means, you have identified a section of
+code that you think can be made to run faster.
+
+The first thing you will want to do is make sure that the piece of code is actually taking up
+a notable amount of time to run. It is usually not worth optimizing something which accounts for less than
+0.0001% of the total running time. Luckily, there are tools to help with this.
+Profilers will let you see how much time your code spends inside a particular function.
+If your target code snippet is only part of a function, it might be worth trying to
+isolate that snippet by moving it to its own function (this is usually not necessary but
+might be).
+
+Most profilers (including the profilers discussed below) will generate a call graph of
+functions for you. Your goal will be to find your function of interest in this call graph
+and then inspect the time spent inside of it. You might also want to to look at the
+annotated assembly which most profilers will provide you with.
+
+#### Instruments
+We will once again consider the scenario where you think you've identified a piece of code
+whose performance can be improved upon. Follow these steps to profile your code using
+Instruments.
+
+1. Open Instruments
+2. Select `Time Profiler` from the list of standard templates
+3. Close all other applications except for your instruments window and your terminal
+4. Run your benchmarking script from your terminal window
+    * You will want a benchmark that runs for at least a few seconds (5 seconds will
+    usually be long enough). This way the profiler will have something to work with
+    and you will have ample time to attach your profiler to this process:)
+    * I will just use benchzstd as my bencharmking script for this example:
+```
+$ zstd -b1 -i5 <my-data> # this will run for 5 seconds
+```
+5. Once you run your benchmarking script, switch back over to instruments and attach your
+process to the time profiler. You can do this by:
+    * Clicking on the `All Processes` drop down in the top left of the toolbar.
+    * Selecting your process from the dropdown. In my case, it is just going to be labeled
+    `zstd`
+    * Hitting the bright red record circle button on the top left of the toolbar
+6. You profiler will now start collecting metrics from your benchmarking script. Once
+you think you have collected enough samples (usually this is the case after 3 seconds of
+recording), stop your profiler.
+7. Make sure that in toolbar of the bottom window, `profile` is selected.
+8. You should be able to see your call graph.
+    * If you don't see the call graph or an incomplete call graph, make sure you have compiled
+    zstd and your benchmarking script using debug flags. On mac and linux, this just means
+    you will have to supply the `-g` flag alone with your build script. You might also
+    have to provide the `-fno-omit-frame-pointer` flag
+9. Dig down the graph to find your function call and then inspect it by double clicking
+the list item. You will be able to see the annotated source code and the assembly side by
+side.
+
+#### Perf
+
+This wiki has a pretty detailed tutorial on getting started working with perf so we'll
+leave you to check that out of you're getting started:
+
+https://perf.wiki.kernel.org/index.php/Tutorial
+
+Some general notes on perf:
+* Use `perf stat -r # <bench-program>` to quickly get some relevant timing and
+counter statistics. Perf uses a high resolution timer and this is likely one
+of the first things your team will run when assessing your PR.
+* Perf has a long list of hardware counters that can be viewed with `perf --list`.
+When measuring optimizations, something worth trying is to make sure the hardware
+counters you expect to be impacted by your change are in fact being so. For example,
+if you expect the L1 cache misses to decrease with your change, you can look at the
+counter `L1-dcache-load-misses`
+* Perf hardware counters will not work on a virtual machine.
+
+#### Visual Studio
+
+TODO
+
+## Issues
+We use GitHub issues to track public bugs. Please ensure your description is
+clear and has sufficient instructions to be able to reproduce the issue.
+
+Facebook has a [bounty program](https://www.facebook.com/whitehat/) for the safe
+disclosure of security bugs. In those cases, please go through the process
+outlined on that page and do not file a public issue.
+
+## Coding Style
+It's a pretty long topic, which is difficult to summarize in a single paragraph.
+As a rule of thumbs, try to imitate the coding style of
+similar lines of codes around your contribution.
+The following is a non-exhaustive list of rules employed in zstd code base:
+
+### C90
+This code base is following strict C90 standard,
+with 2 extensions : 64-bit `long long` types, and variadic macros.
+This rule is applied strictly to code within `lib/` and `programs/`.
+Sub-project in `contrib/` are allowed to use other conventions.
+
+### C++ direct compatibility : symbol mangling
+All public symbol declarations must be wrapped in `extern “C” { … }`,
+so that this project can be compiled as C++98 code,
+and linked into C++ applications.
+
+### Minimal Frugal
+This design requirement is fundamental to preserve the portability of the code base.
+#### Dependencies
+- Reduce dependencies to the minimum possible level.
+  Any dependency should be considered “bad” by default,
+  and only tolerated because it provides a service in a better way than can be achieved locally.
+  The only external dependencies this repository tolerates are
+  standard C libraries, and in rare cases, system level headers.
+- Within `lib/`, this policy is even more drastic.
+  The only external dependencies allowed are `<assert.h>`, `<stdlib.h>`, `<string.h>`,
+  and even then, not directly.
+  In particular, no function shall ever allocate on heap directly,
+  and must use instead `ZSTD_malloc()` and equivalent.
+  Other accepted non-symbol headers are `<stddef.h>` and `<limits.h>`.
+- Within the project, there is a strict hierarchy of dependencies that must be respected.
+  `programs/` is allowed to depend on `lib/`, but only its public API.
+  Within `lib/`, `lib/common` doesn't depend on any other directory.
+  `lib/compress` and `lib/decompress` shall not depend on each other.
+  `lib/dictBuilder` can depend on `lib/common` and `lib/compress`, but not `lib/decompress`.
+#### Resources
+- Functions in `lib/` must use very little stack space,
+  several dozens of bytes max.
+  Everything larger must use the heap allocator,
+  or require a scratch buffer to be emplaced manually.
+
+### Naming
+* All public symbols are prefixed with `ZSTD_`
+  + private symbols, with a scope limited to their own unit, are free of this restriction.
+    However, since `libzstd` source code can be amalgamated,
+    each symbol name must attempt to be (and remain) unique.
+    Avoid too generic names that could become ground for future collisions.
+    This generally implies usage of some form of prefix.
+* For symbols (functions and variables), naming convention is `PREFIX_camelCase`.
+  + In some advanced cases, one can also find :
+    - `PREFIX_prefix2_camelCase`
+    - `PREFIX_camelCase_extendedQualifier`
+* Multi-words names generally consist of an action followed by object:
+  - for example : `ZSTD_createCCtx()`
+* Prefer positive actions
+  - `goBackward` rather than `notGoForward`
+* Type names (`struct`, etc.) follow similar convention,
+  except that they are allowed and even invited to start by an Uppercase letter.
+  Example : `ZSTD_CCtx`, `ZSTD_CDict`
+* Macro names are all Capital letters.
+  The same composition rules (`PREFIX_NAME_QUALIFIER`) apply.
+* File names are all lowercase letters.
+  The convention is `snake_case`.
+  File names **must** be unique across the entire code base,
+  even when they stand in clearly separated directories.
+
+### Qualifiers
+* This code base is `const` friendly, if not `const` fanatical.
+  Any variable that can be `const` (aka. read-only) **must** be `const`.
+  Any pointer which content will not be modified must be `const`.
+  This property is then controlled at compiler level.
+  `const` variables are an important signal to readers that this variable isn’t modified.
+  Conversely, non-const variables are a signal to readers to watch out for modifications later on in the function.
+* If a function must be inlined, mention it explicitly,
+  using project's own portable macros, such as `FORCE_INLINE_ATTR`,
+  defined in `lib/common/compiler.h`.
+
+### Debugging
+* **Assertions** are welcome, and should be used very liberally,
+  to control any condition the code expects for its correct execution.
+  These assertion checks will be run in debug builds, and disabled in production.
+* For traces, this project provides its own debug macros,
+  in particular `DEBUGLOG(level, ...)`, defined in `lib/common/debug.h`.
+
+### Code documentation
+* Avoid code documentation that merely repeats what the code is already stating.
+  Whenever applicable, prefer employing the code as the primary way to convey explanations.
+  Example 1 : `int nbTokens = n;` instead of `int i = n; /* i is a nb of tokens *./`.
+  Example 2 : `assert(size > 0);` instead of `/* here, size should be positive */`.
+* At declaration level, the documentation explains how to use the function or variable
+  and when applicable why it's needed, of the scenarios where it can be useful.
+* At implementation level, the documentation explains the general outline of the algorithm employed,
+  and when applicable why this specific choice was preferred.
+
+### General layout
+* 4 spaces for indentation rather than tabs
+* Code documentation shall directly precede function declaration or implementation
+* Function implementations and its code documentation should be preceded and followed by an empty line
+
+
+## License
+By contributing to Zstandard, you agree that your contributions will be licensed
+under both the [LICENSE](LICENSE) file and the [COPYING](COPYING) file in the root directory of this source tree.

SPANN/ThirdParty/zstd/Makefile

@@ -0,0 +1,439 @@
+# ################################################################
+# Copyright (c) 2015-2021, Yann Collet, Facebook, Inc.
+# All rights reserved.
+#
+# This source code is licensed under both the BSD-style license (found in the
+# LICENSE file in the root directory of this source tree) and the GPLv2 (found
+# in the COPYING file in the root directory of this source tree).
+# You may select, at your option, one of the above-listed licenses.
+# ################################################################
+
+# verbose mode (print commands) on V=1 or VERBOSE=1
+Q = $(if $(filter 1,$(V) $(VERBOSE)),,@)
+
+PRGDIR   = programs
+ZSTDDIR  = lib
+BUILDIR  = build
+ZWRAPDIR = zlibWrapper
+TESTDIR  = tests
+FUZZDIR  = $(TESTDIR)/fuzz
+
+# Define nul output
+VOID = /dev/null
+
+# When cross-compiling from linux to windows, you might
+# need to specify this as "Windows." Fedora build fails
+# without it.
+#
+# Note: mingw-w64 build from linux to windows does not
+# fail on other tested distros (ubuntu, debian) even
+# without manually specifying the TARGET_SYSTEM.
+TARGET_SYSTEM ?= $(OS)
+CP ?= cp
+
+ifneq (,$(filter Windows%,$(TARGET_SYSTEM)))
+  EXT =.exe
+else
+  EXT =
+endif
+
+## default: Build lib-release and zstd-release
+.PHONY: default
+default: lib-release zstd-release
+
+.PHONY: all
+all: allmost examples manual contrib
+
+.PHONY: allmost
+allmost: allzstd zlibwrapper
+
+# skip zwrapper, can't build that on alternate architectures without the proper zlib installed
+.PHONY: allzstd
+allzstd: lib
+	$(Q)$(MAKE) -C $(PRGDIR) all
+	$(Q)$(MAKE) -C $(TESTDIR) all
+
+.PHONY: all32
+all32:
+	$(MAKE) -C $(PRGDIR) zstd32
+	$(MAKE) -C $(TESTDIR) all32
+
+.PHONY: lib lib-release lib-mt lib-nomt
+lib lib-release lib-mt lib-nomt:
+	$(Q)$(MAKE) -C $(ZSTDDIR) $@
+
+.PHONY: zstd zstd-release
+zstd zstd-release:
+	$(Q)$(MAKE) -C $(PRGDIR) $@
+	$(Q)ln -sf $(PRGDIR)/zstd$(EXT) zstd$(EXT)
+
+.PHONY: zstdmt
+zstdmt:
+	$(Q)$(MAKE) -C $(PRGDIR) $@
+	$(Q)$(CP) $(PRGDIR)/zstd$(EXT) ./zstdmt$(EXT)
+
+.PHONY: zlibwrapper
+zlibwrapper: lib
+	$(MAKE) -C $(ZWRAPDIR) all
+
+## test: run long-duration tests
+.PHONY: test
+DEBUGLEVEL ?= 1
+test: MOREFLAGS += -g -Werror
+test:
+	DEBUGLEVEL=$(DEBUGLEVEL) MOREFLAGS="$(MOREFLAGS)" $(MAKE) -j -C $(PRGDIR) allVariants
+	$(MAKE) -C $(TESTDIR) $@
+	ZSTD=../../programs/zstd $(MAKE) -C doc/educational_decoder $@
+
+## shortest: same as `make check`
+.PHONY: shortest
+shortest:
+	$(Q)$(MAKE) -C $(TESTDIR) $@
+
+## check: run basic tests for `zstd` cli
+.PHONY: check
+check: shortest
+
+.PHONY: automated_benchmarking
+automated_benchmarking:
+	$(MAKE) -C $(TESTDIR) $@
+
+.PHONY: benchmarking
+benchmarking: automated_benchmarking
+
+## examples: build all examples in `examples/` directory
+.PHONY: examples
+examples: lib
+	$(MAKE) -C examples all
+
+## manual: generate API documentation in html format
+.PHONY: manual
+manual:
+	$(MAKE) -C contrib/gen_html $@
+
+## man: generate man page
+.PHONY: man
+man:
+	$(MAKE) -C programs $@
+
+## contrib: build all supported projects in `/contrib` directory
+.PHONY: contrib
+contrib: lib
+	$(MAKE) -C contrib/pzstd all
+	$(MAKE) -C contrib/seekable_format/examples all
+	$(MAKE) -C contrib/seekable_format/tests test
+	$(MAKE) -C contrib/largeNbDicts all
+	cd build/single_file_libs/ ; ./build_decoder_test.sh
+	cd build/single_file_libs/ ; ./build_library_test.sh
+
+.PHONY: cleanTabs
+cleanTabs:
+	cd contrib; ./cleanTabs
+
+.PHONY: clean
+clean:
+	$(Q)$(MAKE) -C $(ZSTDDIR) $@ > $(VOID)
+	$(Q)$(MAKE) -C $(PRGDIR) $@ > $(VOID)
+	$(Q)$(MAKE) -C $(TESTDIR) $@ > $(VOID)
+	$(Q)$(MAKE) -C $(ZWRAPDIR) $@ > $(VOID)
+	$(Q)$(MAKE) -C examples/ $@ > $(VOID)
+	$(Q)$(MAKE) -C contrib/gen_html $@ > $(VOID)
+	$(Q)$(MAKE) -C contrib/pzstd $@ > $(VOID)
+	$(Q)$(MAKE) -C contrib/seekable_format/examples $@ > $(VOID)
+	$(Q)$(MAKE) -C contrib/seekable_format/tests $@ > $(VOID)
+	$(Q)$(MAKE) -C contrib/largeNbDicts $@ > $(VOID)
+	$(Q)$(RM) zstd$(EXT) zstdmt$(EXT) tmp*
+	$(Q)$(RM) -r lz4
+	@echo Cleaning completed
+
+#------------------------------------------------------------------------------
+# make install is validated only for Linux, macOS, Hurd and some BSD targets
+#------------------------------------------------------------------------------
+ifneq (,$(filter $(shell uname),Linux Darwin GNU/kFreeBSD GNU OpenBSD FreeBSD DragonFly NetBSD MSYS_NT Haiku AIX))
+
+HOST_OS = POSIX
+
+MKDIR ?= mkdir -p
+
+HAVE_COLORNEVER = $(shell echo a | egrep --color=never a > /dev/null 2> /dev/null && echo 1 || echo 0)
+EGREP_OPTIONS ?=
+ifeq ($HAVE_COLORNEVER, 1)
+EGREP_OPTIONS += --color=never
+endif
+EGREP = egrep $(EGREP_OPTIONS)
+
+# Print a two column output of targets and their description. To add a target description, put a
+# comment in the Makefile with the format "## <TARGET>: <DESCRIPTION>".  For example:
+#
+## list: Print all targets and their descriptions (if provided)
+.PHONY: list
+list:
+	$(Q)TARGETS=$$($(MAKE) -pRrq -f $(lastword $(MAKEFILE_LIST)) : 2>/dev/null \
+		| awk -v RS= -F: '/^# File/,/^# Finished Make data base/ {if ($$1 !~ "^[#.]") {print $$1}}' \
+		| $(EGREP) -v  -e '^[^[:alnum:]]' | sort); \
+	{ \
+	    printf "Target Name\tDescription\n"; \
+	    printf "%0.s-" {1..16}; printf "\t"; printf "%0.s-" {1..40}; printf "\n"; \
+	    for target in $$TARGETS; do \
+	        line=$$($(EGREP) "^##[[:space:]]+$$target:" $(lastword $(MAKEFILE_LIST))); \
+	        description=$$(echo $$line | awk '{i=index($$0,":"); print substr($$0,i+1)}' | xargs); \
+	        printf "$$target\t$$description\n"; \
+	    done \
+	} | column -t -s $$'\t'
+
+.PHONY: install armtest usan asan uasan msan asan32
+install:
+	$(Q)$(MAKE) -C $(ZSTDDIR) $@
+	$(Q)$(MAKE) -C $(PRGDIR) $@
+
+.PHONY: uninstall
+uninstall:
+	$(Q)$(MAKE) -C $(ZSTDDIR) $@
+	$(Q)$(MAKE) -C $(PRGDIR) $@
+
+.PHONY: travis-install
+travis-install:
+	$(MAKE) install PREFIX=~/install_test_dir
+
+.PHONY: gcc5build gcc6build gcc7build clangbuild m32build armbuild aarch64build ppcbuild ppc64build
+gcc5build: clean
+	gcc-5 -v
+	CC=gcc-5 $(MAKE) all MOREFLAGS="-Werror"
+
+gcc6build: clean
+	gcc-6 -v
+	CC=gcc-6 $(MAKE) all MOREFLAGS="-Werror"
+
+gcc7build: clean
+	gcc-7 -v
+	CC=gcc-7 $(MAKE) all MOREFLAGS="-Werror"
+
+clangbuild: clean
+	clang -v
+	CXX=clang++ CC=clang CFLAGS="-Werror -Wconversion -Wno-sign-conversion -Wdocumentation" $(MAKE) all
+
+m32build: clean
+	gcc -v
+	$(MAKE) all32
+
+armbuild: clean
+	CC=arm-linux-gnueabi-gcc CFLAGS="-Werror" $(MAKE) allzstd
+
+aarch64build: clean
+	CC=aarch64-linux-gnu-gcc CFLAGS="-Werror -O0" $(MAKE) allzstd
+
+ppcbuild: clean
+	CC=powerpc-linux-gnu-gcc CFLAGS="-m32 -Wno-attributes -Werror" $(MAKE) -j allzstd
+
+ppc64build: clean
+	CC=powerpc-linux-gnu-gcc CFLAGS="-m64 -Werror" $(MAKE) -j allzstd
+
+.PHONY: armfuzz aarch64fuzz ppcfuzz ppc64fuzz
+armfuzz: clean
+	CC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static MOREFLAGS="-static" FUZZER_FLAGS=--no-big-tests $(MAKE) -C $(TESTDIR) fuzztest
+
+aarch64fuzz: clean
+	ld -v
+	CC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static MOREFLAGS="-static" FUZZER_FLAGS=--no-big-tests $(MAKE) -C $(TESTDIR) fuzztest
+
+ppcfuzz: clean
+	CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static MOREFLAGS="-static" FUZZER_FLAGS=--no-big-tests $(MAKE) -C $(TESTDIR) fuzztest
+
+ppc64fuzz: clean
+	CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static MOREFLAGS="-m64 -static" FUZZER_FLAGS=--no-big-tests $(MAKE) -C $(TESTDIR) fuzztest
+
+.PHONY: cxxtest gcc5test gcc6test armtest aarch64test ppctest ppc64test
+cxxtest: CXXFLAGS += -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror
+cxxtest: clean
+	$(MAKE) -C $(PRGDIR) all CC="$(CXX) -Wno-deprecated" CFLAGS="$(CXXFLAGS)"   # adding -Wno-deprecated to avoid clang++ warning on dealing with C files directly
+
+gcc5test: clean
+	gcc-5 -v
+	$(MAKE) all CC=gcc-5 MOREFLAGS="-Werror"
+
+gcc6test: clean
+	gcc-6 -v
+	$(MAKE) all CC=gcc-6 MOREFLAGS="-Werror"
+
+armtest: clean
+	$(MAKE) -C $(TESTDIR) datagen   # use native, faster
+	$(MAKE) -C $(TESTDIR) test CC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static ZSTDRTTEST= MOREFLAGS="-Werror -static" FUZZER_FLAGS=--no-big-tests
+
+aarch64test:
+	$(MAKE) -C $(TESTDIR) datagen   # use native, faster
+	$(MAKE) -C $(TESTDIR) test CC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static ZSTDRTTEST= MOREFLAGS="-Werror -static" FUZZER_FLAGS=--no-big-tests
+
+ppctest: clean
+	$(MAKE) -C $(TESTDIR) datagen   # use native, faster
+	$(MAKE) -C $(TESTDIR) test CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static ZSTDRTTEST= MOREFLAGS="-Werror -Wno-attributes -static" FUZZER_FLAGS=--no-big-tests
+
+ppc64test: clean
+	$(MAKE) -C $(TESTDIR) datagen   # use native, faster
+	$(MAKE) -C $(TESTDIR) test CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static ZSTDRTTEST= MOREFLAGS="-m64 -static" FUZZER_FLAGS=--no-big-tests
+
+.PHONY: arm-ppc-compilation
+arm-ppc-compilation:
+	$(MAKE) -C $(PRGDIR) clean zstd CC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static ZSTDRTTEST= MOREFLAGS="-Werror -static"
+	$(MAKE) -C $(PRGDIR) clean zstd CC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static ZSTDRTTEST= MOREFLAGS="-Werror -static"
+	$(MAKE) -C $(PRGDIR) clean zstd CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static ZSTDRTTEST= MOREFLAGS="-Werror -Wno-attributes -static"
+	$(MAKE) -C $(PRGDIR) clean zstd CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static ZSTDRTTEST= MOREFLAGS="-m64 -static"
+
+regressiontest:
+	$(MAKE) -C $(FUZZDIR) regressiontest
+
+uasanregressiontest:
+	$(MAKE) -C $(FUZZDIR) regressiontest CC=clang CXX=clang++ CFLAGS="-O3 -fsanitize=address,undefined" CXXFLAGS="-O3 -fsanitize=address,undefined"
+
+msanregressiontest:
+	$(MAKE) -C $(FUZZDIR) regressiontest CC=clang CXX=clang++ CFLAGS="-O3 -fsanitize=memory" CXXFLAGS="-O3 -fsanitize=memory"
+
+update_regressionResults : REGRESS_RESULTS_DIR := /tmp/regress_results_dir/
+update_regressionResults:
+	$(MAKE) -C programs zstd
+	$(MAKE) -C tests/regression test
+	$(RM) -rf $(REGRESS_RESULTS_DIR)
+	$(MKDIR) $(REGRESS_RESULTS_DIR)
+	./tests/regression/test                         \
+        --cache  tests/regression/cache             \
+        --output $(REGRESS_RESULTS_DIR)/results.csv \
+        --zstd   programs/zstd
+	echo "Showing results differences"
+	! diff tests/regression/results.csv $(REGRESS_RESULTS_DIR)/results.csv
+	echo "Updating results.csv"
+	$(CP) $(REGRESS_RESULTS_DIR)/results.csv tests/regression/results.csv
+
+
+# run UBsan with -fsanitize-recover=pointer-overflow
+# this only works with recent compilers such as gcc 8+
+usan: clean
+	$(MAKE) test CC=clang MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize-recover=pointer-overflow -fsanitize=undefined -Werror"
+
+asan: clean
+	$(MAKE) test CC=clang MOREFLAGS="-g -fsanitize=address -Werror"
+
+asan-%: clean
+	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=address -Werror" $(MAKE) -C $(TESTDIR) $*
+
+msan: clean
+	$(MAKE) test CC=clang MOREFLAGS="-g -fsanitize=memory -fno-omit-frame-pointer -Werror" HAVE_LZMA=0   # datagen.c fails this test for no obvious reason
+
+msan-%: clean
+	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=memory -fno-omit-frame-pointer -Werror" FUZZER_FLAGS=--no-big-tests $(MAKE) -C $(TESTDIR) HAVE_LZMA=0 $*
+
+asan32: clean
+	$(MAKE) -C $(TESTDIR) test32 CC=clang MOREFLAGS="-g -fsanitize=address"
+
+uasan: clean
+	$(MAKE) test CC=clang MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize-recover=pointer-overflow -fsanitize=address,undefined -Werror"
+
+uasan-%: clean
+	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize-recover=pointer-overflow -fsanitize=address,undefined -Werror" $(MAKE) -C $(TESTDIR) $*
+
+tsan-%: clean
+	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=thread -Werror" $(MAKE) -C $(TESTDIR) $* FUZZER_FLAGS=--no-big-tests
+
+.PHONY: apt-install
+apt-install:
+	sudo apt-get -yq --no-install-suggests --no-install-recommends --force-yes install $(APT_PACKAGES)
+
+.PHONY: apt-add-repo
+apt-add-repo:
+	sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+	sudo apt-get update -y -qq
+
+.PHONY: ppcinstall arminstall valgrindinstall libc6install gcc6install gcc7install gcc8install gpp6install clang38install lz4install
+ppcinstall:
+	APT_PACKAGES="qemu-system-ppc qemu-user-static gcc-powerpc-linux-gnu" $(MAKE) apt-install
+
+arminstall:
+	APT_PACKAGES="qemu-system-arm qemu-user-static gcc-arm-linux-gnueabi libc6-dev-armel-cross gcc-aarch64-linux-gnu libc6-dev-arm64-cross" $(MAKE) apt-install
+
+valgrindinstall:
+	APT_PACKAGES="valgrind" $(MAKE) apt-install
+
+libc6install:
+	APT_PACKAGES="libc6-dev-i386 gcc-multilib" $(MAKE) apt-install
+
+gcc6install: apt-add-repo
+	APT_PACKAGES="libc6-dev-i386 gcc-multilib gcc-6 gcc-6-multilib" $(MAKE) apt-install
+
+gcc7install: apt-add-repo
+	APT_PACKAGES="libc6-dev-i386 gcc-multilib gcc-7 gcc-7-multilib" $(MAKE) apt-install
+
+gcc8install: apt-add-repo
+	APT_PACKAGES="libc6-dev-i386 gcc-multilib gcc-8 gcc-8-multilib" $(MAKE) apt-install
+
+gpp6install: apt-add-repo
+	APT_PACKAGES="libc6-dev-i386 g++-multilib gcc-6 g++-6 g++-6-multilib" $(MAKE) apt-install
+
+clang38install:
+	APT_PACKAGES="clang-3.8" $(MAKE) apt-install
+
+# Ubuntu 14.04 ships a too-old lz4
+lz4install:
+	[ -e lz4 ] || git clone https://github.com/lz4/lz4 && sudo $(MAKE) -C lz4 install
+
+endif
+
+
+CMAKE_PARAMS = -DZSTD_BUILD_CONTRIB:BOOL=ON -DZSTD_BUILD_STATIC:BOOL=ON -DZSTD_BUILD_TESTS:BOOL=ON -DZSTD_ZLIB_SUPPORT:BOOL=ON -DZSTD_LZMA_SUPPORT:BOOL=ON -DCMAKE_BUILD_TYPE=Release
+
+ifneq (,$(filter MSYS%,$(shell uname)))
+HOST_OS = MSYS
+CMAKE_PARAMS = -G"MSYS Makefiles" -DCMAKE_BUILD_TYPE=Debug -DZSTD_MULTITHREAD_SUPPORT:BOOL=OFF -DZSTD_BUILD_STATIC:BOOL=ON -DZSTD_BUILD_TESTS:BOOL=ON
+endif
+
+#------------------------------------------------------------------------
+# target specific tests
+#------------------------------------------------------------------------
+ifneq (,$(filter $(HOST_OS),MSYS POSIX))
+.PHONY: cmakebuild c89build gnu90build c99build gnu99build c11build bmix64build bmix32build bmi32build staticAnalyze
+cmakebuild:
+	cmake --version
+	$(RM) -r $(BUILDIR)/cmake/build
+	$(MKDIR) $(BUILDIR)/cmake/build
+	cd $(BUILDIR)/cmake/build; cmake -DCMAKE_INSTALL_PREFIX:PATH=~/install_test_dir $(CMAKE_PARAMS) ..
+	$(MAKE) -C $(BUILDIR)/cmake/build -j4;
+	$(MAKE) -C $(BUILDIR)/cmake/build install;
+	$(MAKE) -C $(BUILDIR)/cmake/build uninstall;
+	cd $(BUILDIR)/cmake/build; ctest -V -L Medium
+
+c89build: clean
+	$(CC) -v
+	CFLAGS="-std=c89 -Werror -O0" $(MAKE) allmost  # will fail, due to missing support for `long long`
+
+gnu90build: clean
+	$(CC) -v
+	CFLAGS="-std=gnu90 -Werror -O0" $(MAKE) allmost
+
+c99build: clean
+	$(CC) -v
+	CFLAGS="-std=c99 -Werror -O0" $(MAKE) allmost
+
+gnu99build: clean
+	$(CC) -v
+	CFLAGS="-std=gnu99 -Werror -O0" $(MAKE) allmost
+
+c11build: clean
+	$(CC) -v
+	CFLAGS="-std=c11 -Werror -O0" $(MAKE) allmost
+
+bmix64build: clean
+	$(CC) -v
+	CFLAGS="-O3 -mbmi -Werror" $(MAKE) -C $(TESTDIR) test
+
+bmix32build: clean
+	$(CC) -v
+	CFLAGS="-O3 -mbmi -mx32 -Werror" $(MAKE) -C $(TESTDIR) test
+
+bmi32build: clean
+	$(CC) -v
+	CFLAGS="-O3 -mbmi -m32 -Werror" $(MAKE) -C $(TESTDIR) test
+
+# static analyzer test uses clang's scan-build
+# does not analyze zlibWrapper, due to detected issues in zlib source code
+staticAnalyze: SCANBUILD ?= scan-build
+staticAnalyze:
+	$(CC) -v
+	CC=$(CC) CPPFLAGS=-g $(SCANBUILD) --status-bugs -v $(MAKE) zstd
+endif

SPANN/ThirdParty/zstd/lib/BUCK

@@ -0,0 +1,232 @@
+cxx_library(
+    name='zstd',
+    header_namespace='',
+    exported_headers=['zstd.h'],
+    visibility=['PUBLIC'],
+    deps=[
+        ':common',
+        ':compress',
+        ':decompress',
+        ':deprecated',
+    ],
+)
+
+cxx_library(
+    name='compress',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=subdir_glob([
+        ('compress', 'zstd*.h'),
+    ]),
+    srcs=glob(['compress/zstd*.c', 'compress/hist.c']),
+    deps=[':common'],
+)
+
+cxx_library(
+    name='decompress',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    headers=subdir_glob([
+        ('decompress', '*_impl.h'),
+    ]),
+    srcs=glob(['decompress/zstd*.c']),
+    deps=[
+        ':common',
+        ':legacy',
+    ],
+)
+
+cxx_library(
+    name='deprecated',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=subdir_glob([
+        ('deprecated', '*.h'),
+    ]),
+    srcs=glob(['deprecated/*.c']),
+    deps=[':common'],
+)
+
+cxx_library(
+    name='legacy',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=subdir_glob([
+        ('legacy', '*.h'),
+    ]),
+    srcs=glob(['legacy/*.c']),
+    deps=[':common'],
+    exported_preprocessor_flags=[
+        '-DZSTD_LEGACY_SUPPORT=4',
+    ],
+)
+
+cxx_library(
+    name='zdict',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=['zdict.h'],
+    headers=subdir_glob([
+        ('dictBuilder', 'divsufsort.h'),
+        ('dictBuilder', 'cover.h'),
+    ]),
+    srcs=glob(['dictBuilder/*.c']),
+    deps=[':common'],
+)
+
+cxx_library(
+    name='compiler',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=subdir_glob([
+        ('common', 'compiler.h'),
+    ]),
+)
+
+cxx_library(
+    name='cpu',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=subdir_glob([
+        ('common', 'cpu.h'),
+    ]),
+)
+
+cxx_library(
+    name='bitstream',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=subdir_glob([
+        ('common', 'bitstream.h'),
+    ]),
+)
+
+cxx_library(
+    name='entropy',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=subdir_glob([
+        ('common', 'fse.h'),
+        ('common', 'huf.h'),
+    ]),
+    srcs=[
+        'common/entropy_common.c',
+        'common/fse_decompress.c',
+        'compress/fse_compress.c',
+        'compress/huf_compress.c',
+        'decompress/huf_decompress.c',
+    ],
+    deps=[
+        ':debug',
+        ':bitstream',
+        ':compiler',
+        ':errors',
+        ':mem',
+    ],
+)
+
+cxx_library(
+    name='errors',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=[
+        'zstd_errors.h',
+        'common/error_private.h',
+    ]
+    srcs=['common/error_private.c'],
+)
+
+cxx_library(
+    name='mem',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=subdir_glob([
+        ('common', 'mem.h'),
+    ]),
+)
+
+cxx_library(
+    name='pool',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=subdir_glob([
+        ('common', 'pool.h'),
+    ]),
+    srcs=['common/pool.c'],
+    deps=[
+        ':threading',
+        ':zstd_common',
+    ],
+)
+
+cxx_library(
+    name='threading',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=subdir_glob([
+        ('common', 'threading.h'),
+    ]),
+    srcs=['common/threading.c'],
+    exported_preprocessor_flags=[
+        '-DZSTD_MULTITHREAD',
+    ],
+    exported_linker_flags=[
+        '-pthread',
+    ],
+)
+
+cxx_library(
+    name='xxhash',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=subdir_glob([
+        ('common', 'xxhash.h'),
+    ]),
+    srcs=['common/xxhash.c'],
+    exported_preprocessor_flags=[
+        '-DXXH_NAMESPACE=ZSTD_',
+    ],
+)
+
+cxx_library(
+    name='zstd_common',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=subdir_glob([
+        ('', 'zstd.h'),
+        ('common', 'zstd_internal.h'),
+    ]),
+    srcs=['common/zstd_common.c'],
+    deps=[
+        ':compiler',
+        ':errors',
+        ':mem',
+    ],
+)
+
+cxx_library(
+    name='debug',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=subdir_glob([
+        ('common', 'debug.h'),
+    ]),
+    srcs=['common/debug.c'],
+)
+
+cxx_library(
+    name='common',
+    deps=[
+        ':debug',
+        ':bitstream',
+        ':compiler',
+        ':cpu',
+        ':entropy',
+        ':errors',
+        ':mem',
+        ':pool',
+        ':threading',
+        ':xxhash',
+        ':zstd_common',
+    ]
+)

SPANN/ThirdParty/zstd/lib/README.md

@@ -0,0 +1,217 @@
+Zstandard library files
+================================
+
+The __lib__ directory is split into several sub-directories,
+in order to make it easier to select or exclude features.
+
+
+#### Building
+
+`Makefile` script is provided, supporting [Makefile conventions](https://www.gnu.org/prep/standards/html_node/Makefile-Conventions.html#Makefile-Conventions),
+including commands variables, staged install, directory variables and standard targets.
+- `make` : generates both static and dynamic libraries
+- `make install` : install libraries and headers in target system directories
+
+`libzstd` default scope is pretty large, including compression, decompression, dictionary builder,
+and support for decoding legacy formats >= v0.5.0.
+The scope can be reduced on demand (see paragraph _modular build_).
+
+
+#### Multithreading support
+
+When building with `make`, by default the dynamic library is multithreaded and static library is single-threaded (for compatibility reasons).
+
+Enabling multithreading requires 2 conditions :
+- set build macro `ZSTD_MULTITHREAD` (`-DZSTD_MULTITHREAD` for `gcc`)
+- for POSIX systems : compile with pthread (`-pthread` compilation flag for `gcc`)
+
+For convenience, we provide a build target to generate multi and single threaded libraries:
+- Force enable multithreading on both dynamic and static libraries by appending `-mt` to the target, e.g. `make lib-mt`.
+- Force disable multithreading on both dynamic and static libraries by appending `-nomt` to the target, e.g. `make lib-nomt`.
+- By default, as mentioned before, dynamic library is multithreaded, and static library is single-threaded, e.g. `make lib`.
+
+When linking a POSIX program with a multithreaded version of `libzstd`,
+note that it's necessary to invoke the `-pthread` flag during link stage.
+
+Multithreading capabilities are exposed
+via the [advanced API defined in `lib/zstd.h`](https://github.com/facebook/zstd/blob/v1.4.3/lib/zstd.h#L351).
+
+
+#### API
+
+Zstandard's stable API is exposed within [lib/zstd.h](zstd.h).
+
+
+#### Advanced API
+
+Optional advanced features are exposed via :
+
+- `lib/zstd_errors.h` : translates `size_t` function results
+                        into a `ZSTD_ErrorCode`, for accurate error handling.
+
+- `ZSTD_STATIC_LINKING_ONLY` : if this macro is defined _before_ including `zstd.h`,
+                          it unlocks access to the experimental API,
+                          exposed in the second part of `zstd.h`.
+                          All definitions in the experimental APIs are unstable,
+                          they may still change in the future, or even be removed.
+                          As a consequence, experimental definitions shall ___never be used with dynamic library___ !
+                          Only static linking is allowed.
+
+
+#### Modular build
+
+It's possible to compile only a limited set of features within `libzstd`.
+The file structure is designed to make this selection manually achievable for any build system :
+
+- Directory `lib/common` is always required, for all variants.
+
+- Compression source code lies in `lib/compress`
+
+- Decompression source code lies in `lib/decompress`
+
+- It's possible to include only `compress` or only `decompress`, they don't depend on each other.
+
+- `lib/dictBuilder` : makes it possible to generate dictionaries from a set of samples.
+        The API is exposed in `lib/dictBuilder/zdict.h`.
+        This module depends on both `lib/common` and `lib/compress` .
+
+- `lib/legacy` : makes it possible to decompress legacy zstd formats, starting from `v0.1.0`.
+        This module depends on `lib/common` and `lib/decompress`.
+        To enable this feature, define `ZSTD_LEGACY_SUPPORT` during compilation.
+        Specifying a number limits versions supported to that version onward.
+        For example, `ZSTD_LEGACY_SUPPORT=2` means : "support legacy formats >= v0.2.0".
+        Conversely, `ZSTD_LEGACY_SUPPORT=0` means "do __not__ support legacy formats".
+        By default, this build macro is set as `ZSTD_LEGACY_SUPPORT=5`.
+        Decoding supported legacy format is a transparent capability triggered within decompression functions.
+        It's also allowed to invoke legacy API directly, exposed in `lib/legacy/zstd_legacy.h`.
+        Each version does also provide its own set of advanced API.
+        For example, advanced API for version `v0.4` is exposed in `lib/legacy/zstd_v04.h` .
+
+- While invoking `make libzstd`, it's possible to define build macros
+        `ZSTD_LIB_COMPRESSION, ZSTD_LIB_DECOMPRESSION`, `ZSTD_LIB_DICTBUILDER`,
+        and `ZSTD_LIB_DEPRECATED` as `0` to forgo compilation of the
+        corresponding features. This will also disable compilation of all
+        dependencies (eg. `ZSTD_LIB_COMPRESSION=0` will also disable
+        dictBuilder).
+
+- There are a number of options that can help minimize the binary size of
+  `libzstd`.
+
+  The first step is to select the components needed (using the above-described
+  `ZSTD_LIB_COMPRESSION` etc.).
+
+  The next step is to set `ZSTD_LIB_MINIFY` to `1` when invoking `make`. This
+  disables various optional components and changes the compilation flags to
+  prioritize space-saving.
+
+  Detailed options: Zstandard's code and build environment is set up by default
+  to optimize above all else for performance. In pursuit of this goal, Zstandard
+  makes significant trade-offs in code size. For example, Zstandard often has
+  more than one implementation of a particular component, with each
+  implementation optimized for different scenarios. For example, the Huffman
+  decoder has complementary implementations that decode the stream one symbol at
+  a time or two symbols at a time. Zstd normally includes both (and dispatches
+  between them at runtime), but by defining `HUF_FORCE_DECOMPRESS_X1` or
+  `HUF_FORCE_DECOMPRESS_X2`, you can force the use of one or the other, avoiding
+  compilation of the other. Similarly, `ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT`
+  and `ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG` force the compilation and use of
+  only one or the other of two decompression implementations. The smallest
+  binary is achieved by using `HUF_FORCE_DECOMPRESS_X1` and
+  `ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT` (implied by `ZSTD_LIB_MINIFY`).
+
+  For squeezing the last ounce of size out, you can also define
+  `ZSTD_NO_INLINE`, which disables inlining, and `ZSTD_STRIP_ERROR_STRINGS`,
+  which removes the error messages that are otherwise returned by
+  `ZSTD_getErrorName` (implied by `ZSTD_LIB_MINIFY`).
+
+  Finally, when integrating into your application, make sure you're doing link-
+  time optimization and unused symbol garbage collection (via some combination of,
+  e.g., `-flto`, `-ffat-lto-objects`, `-fuse-linker-plugin`,
+  `-ffunction-sections`, `-fdata-sections`, `-fmerge-all-constants`,
+  `-Wl,--gc-sections`, `-Wl,-z,norelro`, and an archiver that understands
+  the compiler's intermediate representation, e.g., `AR=gcc-ar`). Consult your
+  compiler's documentation.
+
+- While invoking `make libzstd`, the build macro `ZSTD_LEGACY_MULTITHREADED_API=1`
+  will expose the deprecated `ZSTDMT` API exposed by `zstdmt_compress.h` in
+  the shared library, which is now hidden by default.
+
+- The build macro `DYNAMIC_BMI2` can be set to 1 or 0 in order to generate binaries
+  which can detect at runtime the presence of BMI2 instructions, and use them only if present.
+  These instructions contribute to better performance, notably on the decoder side.
+  By default, this feature is automatically enabled on detecting
+  the right instruction set (x64) and compiler (clang or gcc >= 5).
+  It's obviously disabled for different cpus,
+  or when BMI2 instruction set is _required_ by the compiler command line
+  (in this case, only the BMI2 code path is generated).
+  Setting this macro will either force to generate the BMI2 dispatcher (1)
+  or prevent it (0). It overrides automatic detection.
+
+- The build macro `ZSTD_NO_UNUSED_FUNCTIONS` can be defined to hide the definitions of functions
+  that zstd does not use. Not all unused functions are hidden, but they can be if needed.
+  Currently, this macro will hide function definitions in FSE and HUF that use an excessive
+  amount of stack space.
+
+- The build macro `ZSTD_NO_INTRINSICS` can be defined to disable all explicit intrinsics.
+  Compiler builtins are still used.
+
+- The build macro `ZSTD_DECODER_INTERNAL_BUFFER` can be set to control
+  the amount of extra memory used during decompression to store literals.
+  This defaults to 64kB.  Reducing this value reduces the memory footprint of
+  `ZSTD_DCtx` decompression contexts,
+  but might also result in a small decompression speed cost.
+
+
+#### Windows : using MinGW+MSYS to create DLL
+
+DLL can be created using MinGW+MSYS with the `make libzstd` command.
+This command creates `dll\libzstd.dll` and the import library `dll\libzstd.lib`.
+The import library is only required with Visual C++.
+The header file `zstd.h` and the dynamic library `dll\libzstd.dll` are required to
+compile a project using gcc/MinGW.
+The dynamic library has to be added to linking options.
+It means that if a project that uses ZSTD consists of a single `test-dll.c`
+file it should be linked with `dll\libzstd.dll`. For example:
+```
+    gcc $(CFLAGS) -Iinclude/ test-dll.c -o test-dll dll\libzstd.dll
+```
+The compiled executable will require ZSTD DLL which is available at `dll\libzstd.dll`.
+
+
+#### Advanced Build options
+
+The build system requires a hash function in order to
+separate object files created with different compilation flags.
+By default, it tries to use `md5sum` or equivalent.
+The hash function can be manually switched by setting the `HASH` variable.
+For example : `make HASH=xxhsum`
+The hash function needs to generate at least 64-bit using hexadecimal format.
+When no hash function is found,
+the Makefile just generates all object files into the same default directory,
+irrespective of compilation flags.
+This functionality only matters if `libzstd` is compiled multiple times
+with different build flags.
+
+The build directory, where object files are stored
+can also be manually controlled using variable `BUILD_DIR`,
+for example `make BUILD_DIR=objectDir/v1`.
+In which case, the hash function doesn't matter.
+
+
+#### Deprecated API
+
+Obsolete API on their way out are stored in directory `lib/deprecated`.
+At this stage, it contains older streaming prototypes, in `lib/deprecated/zbuff.h`.
+These prototypes will be removed in some future version.
+Consider migrating code towards supported streaming API exposed in `zstd.h`.
+
+
+#### Miscellaneous
+
+The other files are not source code. There are :
+
+ - `BUCK` : support for `buck` build system (https://buckbuild.com/)
+ - `Makefile` : `make` script to build and install zstd library (static and dynamic)
+ - `README.md` : this file
+ - `dll/` : resources directory for Windows compilation
+ - `libzstd.pc.in` : script for `pkg-config` (used in `make install`)

SPANN/ThirdParty/zstd/lib/common/debug.c

@@ -0,0 +1,24 @@
+/* ******************************************************************
+ * debug
+ * Part of FSE library
+ * Copyright (c) Yann Collet, Facebook, Inc.
+ *
+ * You can contact the author at :
+ * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+****************************************************************** */
+
+
+/*
+ * This module only hosts one global variable
+ * which can be used to dynamically influence the verbosity of traces,
+ * such as DEBUGLOG and RAWLOG
+ */
+
+#include "debug.h"
+
+int g_debuglevel = DEBUGLEVEL;

SPANN/ThirdParty/zstd/lib/libzstd.mk

@@ -0,0 +1,203 @@
+# ################################################################
+# Copyright (c) Yann Collet, Facebook, Inc.
+# All rights reserved.
+#
+# This source code is licensed under both the BSD-style license (found in the
+# LICENSE file in the root directory of this source tree) and the GPLv2 (found
+# in the COPYING file in the root directory of this source tree).
+# You may select, at your option, one of the above-listed licenses.
+# ################################################################
+
+##################################################################
+# Input Variables
+##################################################################
+
+# Zstd lib directory
+LIBZSTD ?= ./
+
+# Legacy support
+ZSTD_LEGACY_SUPPORT ?= 5
+ZSTD_LEGACY_MULTITHREADED_API ?= 0
+
+# Build size optimizations
+HUF_FORCE_DECOMPRESS_X1 ?= 0
+HUF_FORCE_DECOMPRESS_X2 ?= 0
+ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT ?= 0
+ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG ?= 0
+ZSTD_NO_INLINE ?= 0
+ZSTD_STRIP_ERROR_STRINGS ?= 0
+
+# Assembly support
+ZSTD_NO_ASM ?= 0
+
+##################################################################
+# libzstd helpers
+##################################################################
+
+VOID ?= /dev/null
+
+# Make 4.3 doesn't support '\#' anymore (https://lwn.net/Articles/810071/)
+NUM_SYMBOL := \#
+
+# define silent mode as default (verbose mode with V=1 or VERBOSE=1)
+$(V)$(VERBOSE).SILENT:
+
+# When cross-compiling from linux to windows,
+# one might need to specify TARGET_SYSTEM as "Windows."
+# Building from Fedora fails without it.
+# (but Ubuntu and Debian don't need to set anything)
+TARGET_SYSTEM ?= $(OS)
+
+# Version numbers
+LIBVER_SRC := $(LIBZSTD)/zstd.h
+LIBVER_MAJOR_SCRIPT:=`sed -n '/define ZSTD_VERSION_MAJOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < $(LIBVER_SRC)`
+LIBVER_MINOR_SCRIPT:=`sed -n '/define ZSTD_VERSION_MINOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < $(LIBVER_SRC)`
+LIBVER_PATCH_SCRIPT:=`sed -n '/define ZSTD_VERSION_RELEASE/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < $(LIBVER_SRC)`
+LIBVER_SCRIPT:= $(LIBVER_MAJOR_SCRIPT).$(LIBVER_MINOR_SCRIPT).$(LIBVER_PATCH_SCRIPT)
+LIBVER_MAJOR := $(shell echo $(LIBVER_MAJOR_SCRIPT))
+LIBVER_MINOR := $(shell echo $(LIBVER_MINOR_SCRIPT))
+LIBVER_PATCH := $(shell echo $(LIBVER_PATCH_SCRIPT))
+LIBVER := $(shell echo $(LIBVER_SCRIPT))
+CCVER := $(shell $(CC) --version)
+ZSTD_VERSION?= $(LIBVER)
+
+# ZSTD_LIB_MINIFY is a helper variable that
+# configures a bunch of other variables to space-optimized defaults.
+ZSTD_LIB_MINIFY ?= 0
+ifneq ($(ZSTD_LIB_MINIFY), 0)
+  HAVE_CC_OZ ?= $(shell echo "" | $(CC) -Oz -x c -c - -o /dev/null 2> /dev/null && echo 1 || echo 0)
+  ZSTD_LEGACY_SUPPORT ?= 0
+  ZSTD_LIB_DEPRECATED ?= 0
+  HUF_FORCE_DECOMPRESS_X1 ?= 1
+  ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT ?= 1
+  ZSTD_NO_INLINE ?= 1
+  ZSTD_STRIP_ERROR_STRINGS ?= 1
+ifneq ($(HAVE_CC_OZ), 0)
+    # Some compilers (clang) support an even more space-optimized setting.
+    CFLAGS += -Oz
+else
+    CFLAGS += -Os
+endif
+  CFLAGS += -fno-stack-protector -fomit-frame-pointer -fno-ident \
+            -DDYNAMIC_BMI2=0 -DNDEBUG
+else
+  CFLAGS ?= -O3
+endif
+
+DEBUGLEVEL ?= 0
+CPPFLAGS += -DXXH_NAMESPACE=ZSTD_ -DDEBUGLEVEL=$(DEBUGLEVEL)
+ifeq ($(TARGET_SYSTEM),Windows_NT)   # MinGW assumed
+  CPPFLAGS += -D__USE_MINGW_ANSI_STDIO   # compatibility with %zu formatting
+endif
+DEBUGFLAGS= -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \
+            -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \
+            -Wstrict-prototypes -Wundef -Wpointer-arith \
+            -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings \
+            -Wredundant-decls -Wmissing-prototypes -Wc++-compat
+CFLAGS   += $(DEBUGFLAGS) $(MOREFLAGS)
+ASFLAGS  += $(DEBUGFLAGS) $(MOREFLAGS) $(CFLAGS)
+LDFLAGS  += $(MOREFLAGS)
+FLAGS     = $(CPPFLAGS) $(CFLAGS) $(ASFLAGS) $(LDFLAGS)
+
+ifndef ALREADY_APPENDED_NOEXECSTACK
+export ALREADY_APPENDED_NOEXECSTACK := 1
+ifeq ($(shell echo "int main(int argc, char* argv[]) { (void)argc; (void)argv; return 0; }" | $(CC) $(FLAGS) -z noexecstack -x c -Werror - -o $(VOID) 2>$(VOID) && echo 1 || echo 0),1)
+LDFLAGS += -z noexecstack
+endif
+ifeq ($(shell echo | $(CC) $(FLAGS) -Wa,--noexecstack -x assembler -Werror -c - -o $(VOID) 2>$(VOID) && echo 1 || echo 0),1)
+CFLAGS  += -Wa,--noexecstack
+# CFLAGS are also added to ASFLAGS
+else ifeq ($(shell echo | $(CC) $(FLAGS) -Qunused-arguments -Wa,--noexecstack -x assembler -Werror -c - -o $(VOID) 2>$(VOID) && echo 1 || echo 0),1)
+# See e.g.: https://github.com/android/ndk/issues/171
+CFLAGS  += -Qunused-arguments -Wa,--noexecstack
+# CFLAGS are also added to ASFLAGS
+endif
+endif
+
+HAVE_COLORNEVER = $(shell echo a | grep --color=never a > /dev/null 2> /dev/null && echo 1 || echo 0)
+GREP_OPTIONS ?=
+ifeq ($HAVE_COLORNEVER, 1)
+  GREP_OPTIONS += --color=never
+endif
+GREP = grep $(GREP_OPTIONS)
+SED_ERE_OPT ?= -E
+
+ZSTD_COMMON_FILES := $(sort $(wildcard $(LIBZSTD)/common/*.c))
+ZSTD_COMPRESS_FILES := $(sort $(wildcard $(LIBZSTD)/compress/*.c))
+ZSTD_DECOMPRESS_FILES := $(sort $(wildcard $(LIBZSTD)/decompress/*.c))
+ZSTD_DICTBUILDER_FILES := $(sort $(wildcard $(LIBZSTD)/dictBuilder/*.c))
+ZSTD_DEPRECATED_FILES := $(sort $(wildcard $(LIBZSTD)/deprecated/*.c))
+ZSTD_LEGACY_FILES :=
+
+ZSTD_DECOMPRESS_AMD64_ASM_FILES := $(sort $(wildcard $(LIBZSTD)/decompress/*_amd64.S))
+
+ifneq ($(ZSTD_NO_ASM), 0)
+  CPPFLAGS += -DZSTD_DISABLE_ASM
+else
+  # Unconditionally add the ASM files they are disabled by
+  # macros in the .S file.
+  ZSTD_DECOMPRESS_FILES += $(ZSTD_DECOMPRESS_AMD64_ASM_FILES)
+endif
+
+ifneq ($(HUF_FORCE_DECOMPRESS_X1), 0)
+  CFLAGS += -DHUF_FORCE_DECOMPRESS_X1
+endif
+
+ifneq ($(HUF_FORCE_DECOMPRESS_X2), 0)
+  CFLAGS += -DHUF_FORCE_DECOMPRESS_X2
+endif
+
+ifneq ($(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT), 0)
+  CFLAGS += -DZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
+endif
+
+ifneq ($(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG), 0)
+  CFLAGS += -DZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
+endif
+
+ifneq ($(ZSTD_NO_INLINE), 0)
+  CFLAGS += -DZSTD_NO_INLINE
+endif
+
+ifneq ($(ZSTD_STRIP_ERROR_STRINGS), 0)
+  CFLAGS += -DZSTD_STRIP_ERROR_STRINGS
+endif
+
+ifneq ($(ZSTD_LEGACY_MULTITHREADED_API), 0)
+  CFLAGS += -DZSTD_LEGACY_MULTITHREADED_API
+endif
+
+ifneq ($(ZSTD_LEGACY_SUPPORT), 0)
+ifeq ($(shell test $(ZSTD_LEGACY_SUPPORT) -lt 8; echo $$?), 0)
+  ZSTD_LEGACY_FILES += $(shell ls $(LIBZSTD)/legacy/*.c | $(GREP) 'v0[$(ZSTD_LEGACY_SUPPORT)-7]')
+endif
+endif
+CPPFLAGS  += -DZSTD_LEGACY_SUPPORT=$(ZSTD_LEGACY_SUPPORT)
+
+UNAME := $(shell uname)
+
+ifndef BUILD_DIR
+ifeq ($(UNAME), Darwin)
+  ifeq ($(shell md5 < /dev/null > /dev/null; echo $$?), 0)
+    HASH ?= md5
+  endif
+else ifeq ($(UNAME), FreeBSD)
+  HASH ?= gmd5sum
+else ifeq ($(UNAME), NetBSD)
+  HASH ?= md5 -n
+else ifeq ($(UNAME), OpenBSD)
+  HASH ?= md5
+endif
+HASH ?= md5sum
+
+HASH_DIR = conf_$(shell echo $(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) $(ZSTD_FILES) | $(HASH) | cut -f 1 -d " " )
+HAVE_HASH :=$(shell echo 1 | $(HASH) > /dev/null && echo 1 || echo 0)
+ifeq ($(HAVE_HASH),0)
+  $(info warning : could not find HASH ($(HASH)), needed to differentiate builds using different flags)
+  BUILD_DIR := obj/generic_noconf
+endif
+endif # BUILD_DIR
+
+ZSTD_SUBDIR := $(LIBZSTD)/common $(LIBZSTD)/compress $(LIBZSTD)/decompress $(LIBZSTD)/dictBuilder $(LIBZSTD)/legacy $(LIBZSTD)/deprecated
+vpath %.c $(ZSTD_SUBDIR)
+vpath %.S $(ZSTD_SUBDIR)

SPANN/ThirdParty/zstd/lib/libzstd.pc.in

@@ -0,0 +1,16 @@
+#   ZSTD - standard compression algorithm
+#   Copyright (C) 2014-2016, Yann Collet, Facebook
+#   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+prefix=@PREFIX@
+exec_prefix=@EXEC_PREFIX@
+includedir=@INCLUDEDIR@
+libdir=@LIBDIR@
+
+Name: zstd
+Description: fast lossless compression algorithm library
+URL: http://www.zstd.net/
+Version: @VERSION@
+Libs: -L${libdir} -lzstd
+Libs.private: @LIBS_PRIVATE@
+Cflags: -I${includedir}

SPANN/ThirdParty/zstd/lib/module.modulemap

@@ -0,0 +1,25 @@
+module libzstd [extern_c] {
+    header "zstd.h"
+    export *
+    config_macros [exhaustive] /* zstd.h */ \
+        ZSTD_STATIC_LINKING_ONLY, \
+        ZSTDLIB_VISIBLE, \
+        ZSTD_DLL_EXPORT, \
+        ZSTDLIB_STATIC_API, \
+        ZSTD_DISABLE_DEPRECATE_WARNINGS, \
+        ZSTD_CLEVEL_DEFAULT, \
+        /* zdict.h */ ZDICT_STATIC_LINKING_ONLY, \
+        ZDICTLIB_VISIBILITY, \
+        ZDICT_DISABLE_DEPRECATE_WARNINGS, \
+        /* zstd_errors.h */ ZSTDERRORLIB_VISIBILITY
+
+    module dictbuilder [extern_c] {
+        header "zdict.h"
+        export *
+    }
+
+    module errors [extern_c] {
+        header "zstd_errors.h"
+        export *
+    }
+}

SPANN/ThirdParty/zstd/lib/zstd_errors.h

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_ERRORS_H_398273423
+#define ZSTD_ERRORS_H_398273423
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/*===== dependency =====*/
+#include <stddef.h>   /* size_t */
+
+
+/* =====   ZSTDERRORLIB_API : control library symbols visibility   ===== */
+#ifndef ZSTDERRORLIB_VISIBILITY
+#  if defined(__GNUC__) && (__GNUC__ >= 4)
+#    define ZSTDERRORLIB_VISIBILITY __attribute__ ((visibility ("default")))
+#  else
+#    define ZSTDERRORLIB_VISIBILITY
+#  endif
+#endif
+#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
+#  define ZSTDERRORLIB_API __declspec(dllexport) ZSTDERRORLIB_VISIBILITY
+#elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
+#  define ZSTDERRORLIB_API __declspec(dllimport) ZSTDERRORLIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
+#else
+#  define ZSTDERRORLIB_API ZSTDERRORLIB_VISIBILITY
+#endif
+
+/*-*********************************************
+ *  Error codes list
+ *-*********************************************
+ *  Error codes _values_ are pinned down since v1.3.1 only.
+ *  Therefore, don't rely on values if you may link to any version < v1.3.1.
+ *
+ *  Only values < 100 are considered stable.
+ *
+ *  note 1 : this API shall be used with static linking only.
+ *           dynamic linking is not yet officially supported.
+ *  note 2 : Prefer relying on the enum than on its value whenever possible
+ *           This is the only supported way to use the error list < v1.3.1
+ *  note 3 : ZSTD_isError() is always correct, whatever the library version.
+ **********************************************/
+typedef enum {
+  ZSTD_error_no_error = 0,
+  ZSTD_error_GENERIC  = 1,
+  ZSTD_error_prefix_unknown                = 10,
+  ZSTD_error_version_unsupported           = 12,
+  ZSTD_error_frameParameter_unsupported    = 14,
+  ZSTD_error_frameParameter_windowTooLarge = 16,
+  ZSTD_error_corruption_detected = 20,
+  ZSTD_error_checksum_wrong      = 22,
+  ZSTD_error_dictionary_corrupted      = 30,
+  ZSTD_error_dictionary_wrong          = 32,
+  ZSTD_error_dictionaryCreation_failed = 34,
+  ZSTD_error_parameter_unsupported   = 40,
+  ZSTD_error_parameter_outOfBound    = 42,
+  ZSTD_error_tableLog_tooLarge       = 44,
+  ZSTD_error_maxSymbolValue_tooLarge = 46,
+  ZSTD_error_maxSymbolValue_tooSmall = 48,
+  ZSTD_error_stage_wrong       = 60,
+  ZSTD_error_init_missing      = 62,
+  ZSTD_error_memory_allocation = 64,
+  ZSTD_error_workSpace_tooSmall= 66,
+  ZSTD_error_dstSize_tooSmall = 70,
+  ZSTD_error_srcSize_wrong    = 72,
+  ZSTD_error_dstBuffer_null   = 74,
+  /* following error codes are __NOT STABLE__, they can be removed or changed in future versions */
+  ZSTD_error_frameIndex_tooLarge = 100,
+  ZSTD_error_seekableIO          = 102,
+  ZSTD_error_dstBuffer_wrong     = 104,
+  ZSTD_error_srcBuffer_wrong     = 105,
+  ZSTD_error_maxCode = 120  /* never EVER use this value directly, it can change in future versions! Use ZSTD_isError() instead */
+} ZSTD_ErrorCode;
+
+/*! ZSTD_getErrorCode() :
+    convert a `size_t` function result into a `ZSTD_ErrorCode` enum type,
+    which can be used to compare with enum list published above */
+ZSTDERRORLIB_API ZSTD_ErrorCode ZSTD_getErrorCode(size_t functionResult);
+ZSTDERRORLIB_API const char* ZSTD_getErrorString(ZSTD_ErrorCode code);   /**< Same as ZSTD_getErrorName, but using a `ZSTD_ErrorCode` enum argument */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ZSTD_ERRORS_H_398273423 */

SPANN/ThirdParty/zstd/zlibWrapper/.gitignore

@@ -0,0 +1,28 @@
+# object artifacts
+*.o
+
+# Default result files
+_*
+example
+example_zstd.*
+example_gz.*
+fitblk
+fitblk_zstd.*
+zwrapbench
+foo.gz
+
+minigzip
+minigzip_zstd
+example
+example_zstd
+fitblk
+fitblk_zstd
+zwrapbench
+
+# Misc files
+*.bat
+*.zip
+*.txt
+
+# Directories
+minizip/

SPANN/ThirdParty/zstd/zlibWrapper/BUCK

@@ -0,0 +1,22 @@
+cxx_library(
+    name='zlib_wrapper',
+    visibility=['PUBLIC'],
+    exported_linker_flags=['-lz'],
+    header_namespace='',
+    exported_headers=['zstd_zlibwrapper.h'],
+    headers=[
+        'gzcompatibility.h',
+        'gzguts.h',
+    ],
+    srcs=glob(['*.c']),
+    deps=[
+        '//lib:zstd',
+        '//lib:zstd_common',
+    ],
+)
+
+cxx_binary(
+    name='minigzip',
+    srcs=['examples/minigzip.c'],
+    deps=[':zlib_wrapper'],
+)

SPANN/ThirdParty/zstd/zlibWrapper/Makefile

@@ -0,0 +1,119 @@
+# Makefile for example of using zstd wrapper for zlib
+#
+# make - compiles examples
+# make MOREFLAGS=-DZWRAP_USE_ZSTD=1 - compiles examples with zstd compression turned on
+# make test - runs examples
+
+
+# Paths to static and dynamic zlib and zstd libraries
+# Use "make ZLIB_PATH=path/to/zlib ZLIB_LIBRARY=path/to/libz.so" to select a path to library
+ZLIB_LIBRARY ?= -lz
+ZLIB_PATH ?= .
+
+ZSTDLIBDIR = ../lib
+ZSTDLIBRARY = $(ZSTDLIBDIR)/libzstd.a
+ZLIBWRAPPER_PATH = .
+GZFILES = gzclose.o gzlib.o gzread.o gzwrite.o
+EXAMPLE_PATH = examples
+PROGRAMS_PATH = ../programs
+TEST_FILE = ../doc/zstd_compression_format.md
+
+vpath %.c $(PROGRAMS_PATH) $(EXAMPLE_PATH) $(ZLIBWRAPPER_PATH)
+
+
+CPPFLAGS += -DXXH_NAMESPACE=ZSTD_ -I$(ZLIB_PATH) -I$(PROGRAMS_PATH)       \
+            -I$(ZSTDLIBDIR) -I$(ZSTDLIBDIR)/common -I$(ZLIBWRAPPER_PATH)
+STDFLAGS  = -std=c89 -pedantic -Wno-long-long -Wno-variadic-macros -Wc++-compat \
+            -DNO_snprintf -DNO_vsnprintf  # strict ANSI C89 is missing these prototypes
+DEBUGFLAGS= -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow -Wswitch-enum \
+            -Wdeclaration-after-statement -Wstrict-prototypes -Wundef     \
+            -Wstrict-aliasing=1
+CFLAGS   ?= -O3
+CFLAGS   += $(STDFLAGS) $(DEBUGFLAGS)
+CPPFLAGS += $(MOREFLAGS)
+LDLIBS   += $(ZLIB_LIBRARY)
+
+# Define *.exe as extension for Windows systems
+ifneq (,$(filter Windows%,$(OS)))
+EXT =.exe
+else
+EXT =
+endif
+
+default : release
+
+release : STDFLAGS =
+release : DEBUGFLAGS =
+release : all
+
+all: fitblk example zwrapbench minigzip
+
+test: example fitblk example_zstd fitblk_zstd zwrapbench minigzip minigzip_zstd
+	./example
+	./example_zstd
+	./fitblk 10240 <$(TEST_FILE)
+	./fitblk 40960 <$(TEST_FILE)
+	./fitblk_zstd 10240 <$(TEST_FILE)
+	./fitblk_zstd 40960 <$(TEST_FILE)
+	@echo ---- minigzip start ----
+	./minigzip_zstd example$(EXT)
+	#cp example$(EXT).gz example$(EXT)_zstd.gz
+	./minigzip_zstd -d example$(EXT).gz
+	./minigzip example$(EXT)
+	#cp example$(EXT).gz example$(EXT)_gz.gz
+	./minigzip_zstd -d example$(EXT).gz
+	@echo ---- minigzip end ----
+	./zwrapbench -qi1b3B1K $(TEST_FILE)
+	./zwrapbench -rqi1b1e3 ../lib
+
+#valgrindTest: ZSTDLIBRARY = $(ZSTDLIBDIR)/libzstd.so
+valgrindTest: VALGRIND = LD_LIBRARY_PATH=$(ZSTDLIBDIR) valgrind --track-origins=yes --leak-check=full --error-exitcode=1
+valgrindTest: clean example fitblk example_zstd fitblk_zstd zwrapbench
+	@echo "\n ---- valgrind tests ----"
+	$(VALGRIND) ./example
+	$(VALGRIND) ./example_zstd
+	$(VALGRIND) ./fitblk 10240 <$(TEST_FILE)
+	$(VALGRIND) ./fitblk 40960 <$(TEST_FILE)
+	$(VALGRIND) ./fitblk_zstd 10240 <$(TEST_FILE)
+	$(VALGRIND) ./fitblk_zstd 40960 <$(TEST_FILE)
+	$(VALGRIND) ./zwrapbench -qi1b3B1K $(TEST_FILE)
+	$(VALGRIND) ./zwrapbench -rqi1b1e5 ../lib ../programs ../tests
+
+#.c.o:
+#	$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@
+
+minigzip: minigzip.o zstd_zlibwrapper.o $(GZFILES) $(ZSTDLIBRARY)
+
+minigzip_zstd: minigzip.o zstdTurnedOn_zlibwrapper.o $(GZFILES) $(ZSTDLIBRARY)
+	$(LINK.o) $^ $(LDLIBS) $(OUTPUT_OPTION)
+
+example: example.o zstd_zlibwrapper.o $(GZFILES) $(ZSTDLIBRARY)
+
+example_zstd: example.o zstdTurnedOn_zlibwrapper.o $(GZFILES) $(ZSTDLIBRARY)
+	$(LINK.o) $^ $(LDLIBS) $(OUTPUT_OPTION)
+
+fitblk: fitblk.o zstd_zlibwrapper.o $(ZSTDLIBRARY)
+
+fitblk_zstd: fitblk.o zstdTurnedOn_zlibwrapper.o $(ZSTDLIBRARY)
+	$(LINK.o) $^ $(LDLIBS) $(OUTPUT_OPTION)
+
+zwrapbench: zwrapbench.o zstd_zlibwrapper.o util.o timefn.o datagen.o $(ZSTDLIBRARY)
+
+
+zstd_zlibwrapper.o: zstd_zlibwrapper.h
+
+zstdTurnedOn_zlibwrapper.o: CPPFLAGS += -DZWRAP_USE_ZSTD=1
+zstdTurnedOn_zlibwrapper.o: zstd_zlibwrapper.c zstd_zlibwrapper.h
+	$(COMPILE.c) $< $(OUTPUT_OPTION)
+
+
+$(ZSTDLIBRARY):
+	$(MAKE) -C $(ZSTDLIBDIR) libzstd.a
+
+$(ZSTDLIBDIR)/libzstd.so:
+	$(MAKE) -C $(ZSTDLIBDIR) libzstd
+
+
+clean:
+	-$(RM) $(ZLIBWRAPPER_PATH)/*.o $(EXAMPLE_PATH)/*.o *.o foo.gz example$(EXT) example_zstd$(EXT) fitblk$(EXT) fitblk_zstd$(EXT) zwrapbench$(EXT) minigzip$(EXT) minigzip_zstd$(EXT)
+	@echo Cleaning completed