Параллельное выполнение запросов DynamoDB (BatchGetItems для глобального вторичного индекса)

Краткий ответ: Эффективность.

Длинный ответ: функция sum должна создать объект для каждой частичной суммы.

Предположим, что время, необходимое для создания объект прямо пропорционален размеру его данных. Пусть N обозначает количество элементов в последовательности для суммирования.

double s всегда одного размера, что делает время работы sum O (1) × N = O (N) .

int (ранее известное как long) является произвольной длиной. Обозначим через M абсолютное значение наибольшего элемента последовательности. Тогда наихудшее время работы sum: lg (M) + lg (2M) + lg (3M) + ... + lg (NM) = N × lg (M) + lg (N!) = O (N log N).

Для str (где M = длина самой длинной строки) наихудшее время работы: M + 2M + 3M + ... + NM = M × (1 + 2 + ... + N) = O (N²).

Таким образом, строки sum ming будут намного медленнее, чем sum числа ming.

str.join не выделяет никаких промежуточных объектов. Он предопределяет буфер, достаточно большой для хранения объединенных строк, и копирует строковые данные. Он работает в O (N) раз, намного быстрее, чем sum.

1
задан user2967920 9 March 2019 в 05:49
поделиться

1 ответ

Согласно документации , глобальные переменные не зависят от кода обработчика вашей лямбда-функции. Это заставляло буфер со временем накапливаться.

Исправленная ссылка, вставленная ниже.

package main

import (
    "context"
    "fmt"
    "os"
    "sync"

    "github.com/aws/aws-lambda-go/lambda"
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/dynamodb"
    "github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute"
)

func exitWithError(err error) {
    fmt.Fprintln(os.Stderr, err)
    os.Exit(1)
}

//HandleRequest : Lambda entry point
func HandleRequest(ctx context.Context, data LambdaInputJSON) ([]interface{}, error) {
    output := DynamoDBBatchGetRecords(data)
    return output, nil
}

func main() {
    lambda.Start(HandleRequest)
}

func DynamoDBBatchGetRecords(a LambdaInputJSON) []interface{} {
    var dataOut []interface{}
    var wg = &sync.WaitGroup{}
    var mtx = &sync.Mutex{}

    iterations := len(a.Ids)
    wg.Add(iterations)
    for i := 0; i < i; i++ {
        go func(i int) {
            defer wg.Done()
            var outputData []interface{}
            sess, err := session.NewSession(&aws.Config{
                Region: aws.String("aws-region"),
            })
            if err != nil {
                exitWithError(fmt.Errorf("failed to make Query API call, %v", err))
            }
            ddb := dynamodb.New(sess)
            queryInput := &dynamodb.QueryInput{
                Limit:            aws.Int64(1),
                TableName:        aws.String("table"),
                IndexName:        aws.String("index"),
                ScanIndexForward: aws.Bool(false),
                ConsistentRead: aws.Bool(false),
                KeyConditions: map[string]*dynamodb.Condition{
                    "index-column": {
                        ComparisonOperator: aws.String("EQ"),
                        AttributeValueList: []*dynamodb.AttributeValue{
                            {
                                S: aws.String(a.Ids[i]),
                            },
                        },
                    },
                },
            }
            output, err := ddb.Query(queryInput)

            if err != nil {
                exitWithError(fmt.Errorf("E1 failed to make Query API call, %v", err))
            }
            err = dynamodbattribute.UnmarshalListOfMaps(output.Items, &outputData)
            if err != nil {
                exitWithError(fmt.Errorf("E2 failed to unmarshal Query result items, %v", err))
            }

            mtx.Lock()
            dataOut = append(dataOut, outputData[0])
            mtx.Unlock()

        }(i)
    }
    wg.Wait()
    return dataOut
}
0
ответ дан user2967920 9 March 2019 в 05:49
поделиться
Другие вопросы по тегам:

Похожие вопросы: