performance: gjson parsing for readXLMeta, listParts, getObjectInfo. (#2631)

- Using gjson for constructing xlMetaV1{} in realXLMeta. - Test for parsing constructing xlMetaV1{} using gjson. - Changes made since benchmarks showed 30-40% improvement in speed. - Follow up comments in issue https://github.com/minio/minio/issues/2208 for more details. - gjson parsing of parts from xl.json for listParts. - gjson parsing of statInfo from xl.json for getObjectInfo. - Vendorizing gjson dependency.
2025-11-07 04:42:56 -05:00 · 2016-09-09 11:08:18 +05:30
parent 66459a4ce0
commit 8bd78fbdfb
15 changed files with 2249 additions and 38 deletions
--- a/cmd/object-api-getobjectinfo_test.go
+++ b/cmd/object-api-getobjectinfo_test.go
@@ -57,19 +57,19 @@ func testGetObjectInfo(obj ObjectLayer, instanceType string, t TestErrHandler) {
 		{"Test", "", ObjectInfo{}, BucketNameInvalid{Bucket: "Test"}, false},
 		{"---", "", ObjectInfo{}, BucketNameInvalid{Bucket: "---"}, false},
 		{"ad", "", ObjectInfo{}, BucketNameInvalid{Bucket: "ad"}, false},
-		// Test cases with valid but non-existing bucket names (Test number 5-7).
+		// Test cases with valid but non-existing bucket names (Test number 5-6).
 		{"abcdefgh", "abc", ObjectInfo{}, BucketNotFound{Bucket: "abcdefgh"}, false},
 		{"ijklmnop", "efg", ObjectInfo{}, BucketNotFound{Bucket: "ijklmnop"}, false},
-		// Test cases with valid but non-existing bucket names and invalid object name (Test number 8-9).
+		// Test cases with valid but non-existing bucket names and invalid object name (Test number 7-8).
 		{"test-getobjectinfo", "", ObjectInfo{}, ObjectNameInvalid{Bucket: "test-getobjectinfo", Object: ""}, false},
 		{"test-getobjectinfo", "", ObjectInfo{}, ObjectNameInvalid{Bucket: "test-getobjectinfo", Object: ""}, false},
-		// Test cases with non-existing object name with existing bucket (Test number 10-12).
+		// Test cases with non-existing object name with existing bucket (Test number 9-11).
 		{"test-getobjectinfo", "Africa", ObjectInfo{}, ObjectNotFound{Bucket: "test-getobjectinfo", Object: "Africa"}, false},
 		{"test-getobjectinfo", "Antartica", ObjectInfo{}, ObjectNotFound{Bucket: "test-getobjectinfo", Object: "Antartica"}, false},
 		{"test-getobjectinfo", "Asia/myfile", ObjectInfo{}, ObjectNotFound{Bucket: "test-getobjectinfo", Object: "Asia/myfile"}, false},
-		// Test case with existing bucket but object name set to a directory (Test number 13).
+		// Test case with existing bucket but object name set to a directory (Test number 12).
 		{"test-getobjectinfo", "Asia", ObjectInfo{}, ObjectNotFound{Bucket: "test-getobjectinfo", Object: "Asia"}, false},
-		// Valid case with existing object (Test number 14).
+		// Valid case with existing object (Test number 13).
 		{"test-getobjectinfo", "Asia/asiapics.jpg", resultCases[0], nil, true},
 	}
 	for i, testCase := range testCases {
--- a/cmd/xl-v1-metadata.go
+++ b/cmd/xl-v1-metadata.go
@@ -136,9 +136,9 @@ func (m xlMetaV1) IsValid() bool {
 	return m.Version == "1.0.0" && m.Format == "xl"
 }

-// ObjectPartIndex - returns the index of matching object part number.
-func (m xlMetaV1) ObjectPartIndex(partNumber int) int {
-	for i, part := range m.Parts {
+// objectPartIndex - returns the index of matching object part number.
+func objectPartIndex(parts []objectPartInfo, partNumber int) int {
+	for i, part := range parts {
 		if partNumber == part.Number {
 			return i
 		}
@@ -214,16 +214,15 @@ var objMetadataOpIgnoredErrs = []error{
 	errFileNotFound,
 }

-// readXLMetadata - returns the object metadata `xl.json` content from
-// one of the disks picked at random.
-func (xl xlObjects) readXLMetadata(bucket, object string) (xlMeta xlMetaV1, err error) {
+// readXLMetaParts - returns the XL Metadata Parts from xl.json of one of the disks picked at random.
+func (xl xlObjects) readXLMetaParts(bucket, object string) (xlMetaParts []objectPartInfo, err error) {
 	for _, disk := range xl.getLoadBalancedDisks() {
 		if disk == nil {
 			continue
 		}
-		xlMeta, err = readXLMeta(disk, bucket, object)
+		xlMetaParts, err = readXLMetaParts(disk, bucket, object)
 		if err == nil {
-			return xlMeta, nil
+			return xlMetaParts, nil
 		}
 		// For any reason disk or bucket is not available continue
 		// and read from other disks.
@@ -233,7 +232,29 @@ func (xl xlObjects) readXLMetadata(bucket, object string) (xlMeta xlMetaV1, err
 		break
 	}
 	// Return error here.
-	return xlMetaV1{}, err
+	return nil, err
+}
+
+// readXLMetaStat - return xlMetaV1.Stat and xlMetaV1.Meta from  one of the disks picked at random.
+func (xl xlObjects) readXLMetaStat(bucket, object string) (xlStat statInfo, xlMeta map[string]string, err error) {
+	for _, disk := range xl.getLoadBalancedDisks() {
+		if disk == nil {
+			continue
+		}
+		// parses only xlMetaV1.Meta and xlMeta.Stat
+		xlStat, xlMeta, err = readXLMetaStat(disk, bucket, object)
+		if err == nil {
+			return xlStat, xlMeta, nil
+		}
+		// For any reason disk or bucket is not available continue
+		// and read from other disks.
+		if isErrIgnored(err, objMetadataOpIgnoredErrs) {
+			continue
+		}
+		break
+	}
+	// Return error here.
+	return statInfo{}, nil, err
 }

 // deleteXLMetadata - deletes `xl.json` on a single disk.
--- a/cmd/xl-v1-metadata_test.go
+++ b/cmd/xl-v1-metadata_test.go
@@ -55,13 +55,14 @@ func TestAddObjectPart(t *testing.T) {
 			xlMeta.AddObjectPart(testCase.partNum, "part."+partNumString, "etag."+partNumString, int64(testCase.partNum+MiB))
 		}

-		if index := xlMeta.ObjectPartIndex(testCase.partNum); index != testCase.expectedIndex {
+		if index := objectPartIndex(xlMeta.Parts, testCase.partNum); index != testCase.expectedIndex {
 			t.Fatalf("%+v: expected = %d, got: %d", testCase, testCase.expectedIndex, index)
 		}
 	}
 }

-// Test xlMetaV1.ObjectPartIndex()
+// Test objectPartIndex().
+// generates a sample xlMeta data and asserts the output of objectPartIndex() with the expected value.
 func TestObjectPartIndex(t *testing.T) {
 	testCases := []struct {
 		partNum       int
@@ -94,7 +95,7 @@ func TestObjectPartIndex(t *testing.T) {

 	// Test them.
 	for _, testCase := range testCases {
-		if index := xlMeta.ObjectPartIndex(testCase.partNum); index != testCase.expectedIndex {
+		if index := objectPartIndex(xlMeta.Parts, testCase.partNum); index != testCase.expectedIndex {
 			t.Fatalf("%+v: expected = %d, got: %d", testCase, testCase.expectedIndex, index)
 		}
 	}
--- a/cmd/xl-v1-multipart.go
+++ b/cmd/xl-v1-multipart.go
@@ -512,7 +512,7 @@ func (xl xlObjects) listObjectParts(bucket, object, uploadID string, partNumberM

 	uploadIDPath := path.Join(mpartMetaPrefix, bucket, object, uploadID)

-	xlMeta, err := xl.readXLMetadata(minioMetaBucket, uploadIDPath)
+	xlParts, err := xl.readXLMetaParts(minioMetaBucket, uploadIDPath)
 	if err != nil {
 		return ListPartsInfo{}, toObjectErr(err, minioMetaBucket, uploadIDPath)
 	}
@@ -524,7 +524,7 @@ func (xl xlObjects) listObjectParts(bucket, object, uploadID string, partNumberM
 	result.MaxParts = maxParts

 	// For empty number of parts or maxParts as zero, return right here.
-	if len(xlMeta.Parts) == 0 || maxParts == 0 {
+	if len(xlParts) == 0 || maxParts == 0 {
 		return result, nil
 	}

@@ -534,10 +534,10 @@ func (xl xlObjects) listObjectParts(bucket, object, uploadID string, partNumberM
 	}

 	// Only parts with higher part numbers will be listed.
-	partIdx := xlMeta.ObjectPartIndex(partNumberMarker)
-	parts := xlMeta.Parts
+	partIdx := objectPartIndex(xlParts, partNumberMarker)
+	parts := xlParts
 	if partIdx != -1 {
-		parts = xlMeta.Parts[partIdx+1:]
+		parts = xlParts[partIdx+1:]
 	}
 	count := maxParts
 	for _, part := range parts {
@@ -675,7 +675,7 @@ func (xl xlObjects) CompleteMultipartUpload(bucket string, object string, upload

 	// Validate each part and then commit to disk.
 	for i, part := range parts {
-		partIdx := currentXLMeta.ObjectPartIndex(part.PartNumber)
+		partIdx := objectPartIndex(currentXLMeta.Parts, part.PartNumber)
 		// All parts should have same part number.
 		if partIdx == -1 {
 			return "", traceError(InvalidPart{})
@@ -779,7 +779,7 @@ func (xl xlObjects) CompleteMultipartUpload(bucket string, object string, upload

 	// Remove parts that weren't present in CompleteMultipartUpload request.
 	for _, curpart := range currentXLMeta.Parts {
-		if xlMeta.ObjectPartIndex(curpart.Number) == -1 {
+		if objectPartIndex(xlMeta.Parts, curpart.Number) == -1 {
 			// Delete the missing part files. e.g,
 			// Request 1: NewMultipart
 			// Request 2: PutObjectPart 1
--- a/cmd/xl-v1-object.go
+++ b/cmd/xl-v1-object.go
@@ -375,22 +375,23 @@ func (xl xlObjects) GetObjectInfo(bucket, object string) (ObjectInfo, error) {

 // getObjectInfo - wrapper for reading object metadata and constructs ObjectInfo.
 func (xl xlObjects) getObjectInfo(bucket, object string) (objInfo ObjectInfo, err error) {
-	var xlMeta xlMetaV1
-	xlMeta, err = xl.readXLMetadata(bucket, object)
+	// returns xl meta map and stat info.
+	xlStat, xlMetaMap, err := xl.readXLMetaStat(bucket, object)
 	if err != nil {
 		// Return error.
 		return ObjectInfo{}, err
 	}
+
 	objInfo = ObjectInfo{
 		IsDir:           false,
 		Bucket:          bucket,
 		Name:            object,
-		Size:            xlMeta.Stat.Size,
-		ModTime:         xlMeta.Stat.ModTime,
-		MD5Sum:          xlMeta.Meta["md5Sum"],
-		ContentType:     xlMeta.Meta["content-type"],
-		ContentEncoding: xlMeta.Meta["content-encoding"],
-		UserDefined:     xlMeta.Meta,
+		Size:            xlStat.Size,
+		ModTime:         xlStat.ModTime,
+		MD5Sum:          xlMetaMap["md5Sum"],
+		ContentType:     xlMetaMap["content-type"],
+		ContentEncoding: xlMetaMap["content-encoding"],
+		UserDefined:     xlMetaMap,
 	}
 	return objInfo, nil
 }
--- a/cmd/xl-v1-utils.go
+++ b/cmd/xl-v1-utils.go
@@ -17,10 +17,12 @@
 package cmd

 import (
-	"encoding/json"
 	"hash/crc32"
 	"path"
 	"sync"
+	"time"
+
+	"github.com/tidwall/gjson"
 )

 // Returns number of errors that occurred the most (incl. nil) and the
@@ -99,19 +101,160 @@ func hashOrder(key string, cardinality int) []int {
 	return nums
 }

+func parseXLStat(xlMetaBuf []byte) (statInfo, error) {
+	// obtain stat info.
+	stat := statInfo{}
+	// fetching modTime.
+	modTime, err := time.Parse(time.RFC3339, gjson.GetBytes(xlMetaBuf, "stat.modTime").String())
+	if err != nil {
+		return statInfo{}, err
+	}
+	stat.ModTime = modTime
+	// obtain Stat.Size .
+	stat.Size = gjson.GetBytes(xlMetaBuf, "stat.size").Int()
+	return stat, nil
+}
+
+func parseXLVersion(xlMetaBuf []byte) string {
+	return gjson.GetBytes(xlMetaBuf, "version").String()
+}
+
+func parseXLFormat(xlMetaBuf []byte) string {
+	return gjson.GetBytes(xlMetaBuf, "format").String()
+}
+
+func parseXLRelease(xlMetaBuf []byte) string {
+	return gjson.GetBytes(xlMetaBuf, "minio.release").String()
+}
+
+func parseXLErasureInfo(xlMetaBuf []byte) erasureInfo {
+	erasure := erasureInfo{}
+	erasureResult := gjson.GetBytes(xlMetaBuf, "erasure")
+	// parse the xlV1Meta.Erasure.Distribution.
+	disResult := erasureResult.Get("distribution").Array()
+
+	distribution := make([]int, len(disResult))
+	for i, dis := range disResult {
+		distribution[i] = int(dis.Int())
+	}
+	erasure.Distribution = distribution
+
+	erasure.Algorithm = erasureResult.Get("algorithm").String()
+	erasure.DataBlocks = int(erasureResult.Get("data").Int())
+	erasure.ParityBlocks = int(erasureResult.Get("parity").Int())
+	erasure.BlockSize = erasureResult.Get("blockSize").Int()
+	erasure.Index = int(erasureResult.Get("index").Int())
+	// Pare xlMetaV1.Erasure.Checksum array.
+	checkSumsResult := erasureResult.Get("checksum").Array()
+	checkSums := make([]checkSumInfo, len(checkSumsResult))
+	for i, checkSumResult := range checkSumsResult {
+		checkSum := checkSumInfo{}
+		checkSum.Name = checkSumResult.Get("name").String()
+		checkSum.Algorithm = checkSumResult.Get("algorithm").String()
+		checkSum.Hash = checkSumResult.Get("hash").String()
+		checkSums[i] = checkSum
+	}
+	erasure.Checksum = checkSums
+
+	return erasure
+}
+
+func parseXLParts(xlMetaBuf []byte) []objectPartInfo {
+	// Parse the XL Parts.
+	partsResult := gjson.GetBytes(xlMetaBuf, "parts").Array()
+	partInfo := make([]objectPartInfo, len(partsResult))
+	for i, p := range partsResult {
+		info := objectPartInfo{}
+		info.Number = int(p.Get("number").Int())
+		info.Name = p.Get("name").String()
+		info.ETag = p.Get("etag").String()
+		info.Size = p.Get("size").Int()
+		partInfo[i] = info
+	}
+	return partInfo
+}
+
+func parseXLMetaMap(xlMetaBuf []byte) map[string]string {
+	// Get xlMetaV1.Meta map.
+	metaMapResult := gjson.GetBytes(xlMetaBuf, "meta").Map()
+	metaMap := make(map[string]string)
+	for key, valResult := range metaMapResult {
+		metaMap[key] = valResult.String()
+	}
+	return metaMap
+}
+
+// Constructs XLMetaV1 using `gjson` lib to retrieve each field.
+func xlMetaV1UnmarshalJSON(xlMetaBuf []byte) (xlMetaV1, error) {
+	xlMeta := xlMetaV1{}
+	// obtain version.
+	xlMeta.Version = parseXLVersion(xlMetaBuf)
+	// obtain format.
+	xlMeta.Format = parseXLFormat(xlMetaBuf)
+	// Parse xlMetaV1.Stat .
+	stat, err := parseXLStat(xlMetaBuf)
+	if err != nil {
+		return xlMetaV1{}, err
+	}
+
+	xlMeta.Stat = stat
+	// parse the xlV1Meta.Erasure fields.
+	xlMeta.Erasure = parseXLErasureInfo(xlMetaBuf)
+
+	// Parse the XL Parts.
+	xlMeta.Parts = parseXLParts(xlMetaBuf)
+	// Get the xlMetaV1.Realse field.
+	xlMeta.Minio.Release = parseXLRelease(xlMetaBuf)
+	// parse xlMetaV1.
+	xlMeta.Meta = parseXLMetaMap(xlMetaBuf)
+
+	return xlMeta, nil
+}
+
+// read xl.json from the given disk, parse and return xlV1MetaV1.Parts.
+func readXLMetaParts(disk StorageAPI, bucket string, object string) ([]objectPartInfo, error) {
+	// Reads entire `xl.json`.
+	xlMetaBuf, err := disk.ReadAll(bucket, path.Join(object, xlMetaJSONFile))
+	if err != nil {
+		return nil, traceError(err)
+	}
+	// obtain xlMetaV1{}.Partsusing `github.com/tidwall/gjson`.
+	xlMetaParts := parseXLParts(xlMetaBuf)
+
+	return xlMetaParts, nil
+}
+
+// read xl.json from the given disk and parse xlV1Meta.Stat and xlV1Meta.Meta using gjson.
+func readXLMetaStat(disk StorageAPI, bucket string, object string) (statInfo, map[string]string, error) {
+	// Reads entire `xl.json`.
+	xlMetaBuf, err := disk.ReadAll(bucket, path.Join(object, xlMetaJSONFile))
+	if err != nil {
+		return statInfo{}, nil, traceError(err)
+	}
+	// obtain xlMetaV1{}.Meta using `github.com/tidwall/gjson`.
+	xlMetaMap := parseXLMetaMap(xlMetaBuf)
+
+	// obtain xlMetaV1{}.Stat using `github.com/tidwall/gjson`.
+	xlStat, err := parseXLStat(xlMetaBuf)
+	if err != nil {
+		return statInfo{}, nil, traceError(err)
+	}
+	// Return structured `xl.json`.
+	return xlStat, xlMetaMap, nil
+}
+
 // readXLMeta reads `xl.json` and returns back XL metadata structure.
 func readXLMeta(disk StorageAPI, bucket string, object string) (xlMeta xlMetaV1, err error) {
 	// Reads entire `xl.json`.
-	buf, err := disk.ReadAll(bucket, path.Join(object, xlMetaJSONFile))
+	xlMetaBuf, err := disk.ReadAll(bucket, path.Join(object, xlMetaJSONFile))
 	if err != nil {
 		return xlMetaV1{}, traceError(err)
 	}
-
-	// Unmarshal xl metadata.
-	if err = json.Unmarshal(buf, &xlMeta); err != nil {
+	// obtain xlMetaV1{} using `github.com/tidwall/gjson`.
+	xlMeta, err = xlMetaV1UnmarshalJSON(xlMetaBuf)
+	if err != nil {
 		return xlMetaV1{}, traceError(err)
 	}
-
 	// Return structured `xl.json`.
 	return xlMeta, nil
 }
--- a/cmd/xl-v1-utils_test.go
+++ b/cmd/xl-v1-utils_test.go
@@ -17,8 +17,11 @@
 package cmd

 import (
+	"encoding/json"
 	"reflect"
+	"strconv"
 	"testing"
+	"time"
 )

 // Test for reduceErrs, reduceErr reduces collection
@@ -93,3 +96,201 @@ func TestHashOrder(t *testing.T) {
 		t.Errorf("Test: Expect \"nil\" but failed \"%#v\"", hashedOrder)
 	}
 }
+
+// newTestXLMetaV1 - initializes new xlMetaV1, adds version, allocates a fresh erasure info and metadata.
+func newTestXLMetaV1() xlMetaV1 {
+	xlMeta := xlMetaV1{}
+	xlMeta.Version = "1.0.0"
+	xlMeta.Format = "xl"
+	xlMeta.Minio.Release = "1.0.0"
+	xlMeta.Erasure = erasureInfo{
+		Algorithm:    "klauspost/reedsolomon/vandermonde",
+		DataBlocks:   5,
+		ParityBlocks: 5,
+		BlockSize:    10485760,
+		Index:        10,
+		Distribution: []int{9, 10, 1, 2, 3, 4, 5, 6, 7, 8},
+	}
+	xlMeta.Stat = statInfo{
+		Size:    int64(20),
+		ModTime: time.Now().UTC(),
+	}
+	// Set meta data.
+	xlMeta.Meta = make(map[string]string)
+	xlMeta.Meta["testKey1"] = "val1"
+	xlMeta.Meta["testKey2"] = "val2"
+	return xlMeta
+}
+
+func (m *xlMetaV1) AddTestObjectCheckSum(checkSumNum int, name string, hash string, algo string) {
+	checkSum := checkSumInfo{
+		Name:      name,
+		Algorithm: algo,
+		Hash:      hash,
+	}
+	m.Erasure.Checksum[checkSumNum] = checkSum
+}
+
+// AddTestObjectPart - add a new object part in order.
+func (m *xlMetaV1) AddTestObjectPart(partNumber int, partName string, partETag string, partSize int64) {
+	partInfo := objectPartInfo{
+		Number: partNumber,
+		Name:   partName,
+		ETag:   partETag,
+		Size:   partSize,
+	}
+
+	// Proceed to include new part info.
+	m.Parts[partNumber] = partInfo
+}
+
+// Constructs xlMetaV1{} for given number of parts and converts it into bytes.
+func getXLMetaBytes(totalParts int) []byte {
+	xlSampleMeta := getSampleXLMeta(totalParts)
+	xlMetaBytes, err := json.Marshal(xlSampleMeta)
+	if err != nil {
+		panic(err)
+	}
+	return xlMetaBytes
+}
+
+// Returns sample xlMetaV1{} for number of parts.
+func getSampleXLMeta(totalParts int) xlMetaV1 {
+	xlMeta := newTestXLMetaV1()
+	// Number of checksum info == total parts.
+	xlMeta.Erasure.Checksum = make([]checkSumInfo, totalParts)
+	// total number of parts.
+	xlMeta.Parts = make([]objectPartInfo, totalParts)
+	for i := 0; i < totalParts; i++ {
+		partName := "part." + strconv.Itoa(i+1)
+		// hard coding hash and algo value for the checksum, Since we are benchmarking the parsing of xl.json the magnitude doesn't affect the test,
+		// The magnitude doesn't make a difference, only the size does.
+		xlMeta.AddTestObjectCheckSum(i, partName, "a23f5eff248c4372badd9f3b2455a285cd4ca86c3d9a570b091d3fc5cd7ca6d9484bbea3f8c5d8d4f84daae96874419eda578fd736455334afbac2c924b3915a", "blake2b")
+		xlMeta.AddTestObjectPart(i, partName, "d3fdd79cc3efd5fe5c068d7be397934b", 67108864)
+	}
+	return xlMeta
+}
+
+// Compare the unmarshaled XLMetaV1 with the one obtained from gjson parsing.
+func compareXLMetaV1(t *testing.T, unMarshalXLMeta, gjsonXLMeta xlMetaV1) {
+
+	// Start comparing the fields of xlMetaV1 obtained from gjson parsing with one parsed using json unmarshaling.
+	if unMarshalXLMeta.Version != gjsonXLMeta.Version {
+		t.Errorf("Expected the Version to be \"%s\", but got \"%s\".", unMarshalXLMeta.Version, gjsonXLMeta.Version)
+	}
+	if unMarshalXLMeta.Format != gjsonXLMeta.Format {
+		t.Errorf("Expected the format to be \"%s\", but got \"%s\".", unMarshalXLMeta.Format, gjsonXLMeta.Format)
+	}
+	if unMarshalXLMeta.Stat.Size != gjsonXLMeta.Stat.Size {
+		t.Errorf("Expected the stat size to be %v, but got %v.", unMarshalXLMeta.Stat.Size, gjsonXLMeta.Stat.Size)
+	}
+	if unMarshalXLMeta.Stat.ModTime != gjsonXLMeta.Stat.ModTime {
+		t.Errorf("Expected the modTime to be \"%v\", but got \"%v\".", unMarshalXLMeta.Stat.ModTime, gjsonXLMeta.Stat.ModTime)
+	}
+	if unMarshalXLMeta.Erasure.Algorithm != gjsonXLMeta.Erasure.Algorithm {
+		t.Errorf("Expected the erasure algorithm to be \"%v\", but got \"%v\".", unMarshalXLMeta.Erasure.Algorithm, gjsonXLMeta.Erasure.Algorithm)
+	}
+	if unMarshalXLMeta.Erasure.DataBlocks != gjsonXLMeta.Erasure.DataBlocks {
+		t.Errorf("Expected the erasure data blocks to be %v, but got %v.", unMarshalXLMeta.Erasure.DataBlocks, gjsonXLMeta.Erasure.DataBlocks)
+	}
+	if unMarshalXLMeta.Erasure.ParityBlocks != gjsonXLMeta.Erasure.ParityBlocks {
+		t.Errorf("Expected the erasure parity blocks to be %v, but got %v.", unMarshalXLMeta.Erasure.ParityBlocks, gjsonXLMeta.Erasure.ParityBlocks)
+	}
+	if unMarshalXLMeta.Erasure.BlockSize != gjsonXLMeta.Erasure.BlockSize {
+		t.Errorf("Expected the erasure block size to be %v, but got %v.", unMarshalXLMeta.Erasure.BlockSize, gjsonXLMeta.Erasure.BlockSize)
+	}
+	if unMarshalXLMeta.Erasure.Index != gjsonXLMeta.Erasure.Index {
+		t.Errorf("Expected the erasure index to be %v, but got %v.", unMarshalXLMeta.Erasure.Index, gjsonXLMeta.Erasure.Index)
+	}
+	if len(unMarshalXLMeta.Erasure.Distribution) != len(gjsonXLMeta.Erasure.Distribution) {
+		t.Errorf("Expected the size of Erasure Distribution to be %d, but got %d.", len(unMarshalXLMeta.Erasure.Distribution), len(gjsonXLMeta.Erasure.Distribution))
+	} else {
+		for i := 0; i < len(unMarshalXLMeta.Erasure.Distribution); i++ {
+			if unMarshalXLMeta.Erasure.Distribution[i] != gjsonXLMeta.Erasure.Distribution[i] {
+				t.Errorf("Expected the Erasure Distribution to be %d, got %d.", unMarshalXLMeta.Erasure.Distribution[i], gjsonXLMeta.Erasure.Distribution[i])
+			}
+		}
+	}
+
+	if len(unMarshalXLMeta.Erasure.Checksum) != len(gjsonXLMeta.Erasure.Checksum) {
+		t.Errorf("Expected the size of Erasure Checksum to be %d, but got %d.", len(unMarshalXLMeta.Erasure.Checksum), len(gjsonXLMeta.Erasure.Checksum))
+	} else {
+		for i := 0; i < len(unMarshalXLMeta.Erasure.Checksum); i++ {
+			if unMarshalXLMeta.Erasure.Checksum[i].Name != gjsonXLMeta.Erasure.Checksum[i].Name {
+				t.Errorf("Expected the Erasure Checksum Name to be \"%s\", got \"%s\".", unMarshalXLMeta.Erasure.Checksum[i].Name, gjsonXLMeta.Erasure.Checksum[i].Name)
+			}
+			if unMarshalXLMeta.Erasure.Checksum[i].Algorithm != gjsonXLMeta.Erasure.Checksum[i].Algorithm {
+				t.Errorf("Expected the Erasure Checksum Algorithm to be \"%s\", got \"%s.\"", unMarshalXLMeta.Erasure.Checksum[i].Algorithm, gjsonXLMeta.Erasure.Checksum[i].Algorithm)
+			}
+			if unMarshalXLMeta.Erasure.Checksum[i] != gjsonXLMeta.Erasure.Checksum[i] {
+				t.Errorf("Expected the Erasure Checksum Hash to be \"%s\", got \"%s\".", unMarshalXLMeta.Erasure.Checksum[i].Hash, gjsonXLMeta.Erasure.Checksum[i].Hash)
+			}
+		}
+	}
+	if unMarshalXLMeta.Minio.Release != gjsonXLMeta.Minio.Release {
+		t.Errorf("Expected the Release string to be \"%s\", but got \"%s\".", unMarshalXLMeta.Minio.Release, gjsonXLMeta.Minio.Release)
+	}
+	if len(unMarshalXLMeta.Parts) != len(gjsonXLMeta.Parts) {
+		t.Errorf("Expected info of  %d parts to be present, but got %d instead.", len(unMarshalXLMeta.Parts), len(gjsonXLMeta.Parts))
+	} else {
+		for i := 0; i < len(unMarshalXLMeta.Parts); i++ {
+			if unMarshalXLMeta.Parts[i].Name != gjsonXLMeta.Parts[i].Name {
+				t.Errorf("Expected the name of part %d to be \"%s\", got \"%s\".", i+1, unMarshalXLMeta.Parts[i].Name, gjsonXLMeta.Parts[i].Name)
+			}
+			if unMarshalXLMeta.Parts[i].ETag != gjsonXLMeta.Parts[i].ETag {
+				t.Errorf("Expected the ETag of part %d to be \"%s\", got \"%s\".", i+1, unMarshalXLMeta.Parts[i].ETag, gjsonXLMeta.Parts[i].ETag)
+			}
+			if unMarshalXLMeta.Parts[i].Number != gjsonXLMeta.Parts[i].Number {
+				t.Errorf("Expected the number of part %d to be \"%d\", got \"%d\".", i+1, unMarshalXLMeta.Parts[i].Number, gjsonXLMeta.Parts[i].Number)
+			}
+			if unMarshalXLMeta.Parts[i].Size != gjsonXLMeta.Parts[i].Size {
+				t.Errorf("Expected the size of part %d to be %v, got %v.", i+1, unMarshalXLMeta.Parts[i].Size, gjsonXLMeta.Parts[i].Size)
+			}
+		}
+	}
+
+	for key, val := range unMarshalXLMeta.Meta {
+		gjsonVal, exists := gjsonXLMeta.Meta[key]
+		if !exists {
+			t.Errorf("No meta data entry for Key \"%s\" exists.", key)
+		}
+		if val != gjsonVal {
+			t.Errorf("Expected the value for Meta data key \"%s\" to be \"%s\", but got \"%s\".", key, val, gjsonVal)
+		}
+
+	}
+}
+
+// Tests the correctness of constructing XLMetaV1 using gjson lib.
+// The result will be compared with the result obtained from json.unMarshal of the byte data.
+func TestGetXLMetaV1GJson1(t *testing.T) {
+	xlMetaJSON := getXLMetaBytes(1)
+
+	var unMarshalXLMeta xlMetaV1
+	if err := json.Unmarshal(xlMetaJSON, &unMarshalXLMeta); err != nil {
+		t.Errorf("Unmarshalling failed")
+	}
+
+	gjsonXLMeta, err := xlMetaV1UnmarshalJSON(xlMetaJSON)
+	if err != nil {
+		t.Errorf("gjson parsing of XLMeta failed")
+	}
+	compareXLMetaV1(t, unMarshalXLMeta, gjsonXLMeta)
+}
+
+// Tests the correctness of constructing XLMetaV1 using gjson lib for XLMetaV1 of size 10 parts.
+// The result will be compared with the result obtained from json.unMarshal of the byte data.
+func TestGetXLMetaV1GJson10(t *testing.T) {
+
+	xlMetaJSON := getXLMetaBytes(10)
+
+	var unMarshalXLMeta xlMetaV1
+	if err := json.Unmarshal(xlMetaJSON, &unMarshalXLMeta); err != nil {
+		t.Errorf("Unmarshalling failed")
+	}
+	gjsonXLMeta, err := xlMetaV1UnmarshalJSON(xlMetaJSON)
+	if err != nil {
+		t.Errorf("gjson parsing of XLMeta failed")
+	}
+	compareXLMetaV1(t, unMarshalXLMeta, gjsonXLMeta)
+}