You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@druid.apache.org by GitBox <gi...@apache.org> on 2021/05/25 01:07:49 UTC
[GitHub] [druid] loquisgon opened a new pull request #11294: Bound mem dynamic
loquisgon opened a new pull request #11294:
URL: https://github.com/apache/druid/pull/11294
<!-- Thanks for trying to help us make Apache Druid be the best it can be! Please fill out as much of the following information as is possible (where relevant, and remove it when irrelevant) to help make the intention and scope of this PR clear in order to ease review. -->
<!-- Please read the doc for contribution (https://github.com/apache/druid/blob/master/CONTRIBUTING.md) before making this PR. Also, once you open a PR, please _avoid using force pushes and rebasing_ since these make it difficult for reviewers to see what you've changed in response to their reviews. See [the 'If your pull request shows conflicts with master' section](https://github.com/apache/druid/blob/master/CONTRIBUTING.md#if-your-pull-request-shows-conflicts-with-master) for more details. -->
Fixes #XXXX.
<!-- Replace XXXX with the id of the issue fixed in this PR. Remove this section if there is no corresponding issue. Don't reference the issue in the title of this pull-request. -->
<!-- If you are a committer, follow the PR action item checklist for committers:
https://github.com/apache/druid/blob/master/dev/committer-instructions.md#pr-and-issue-action-item-checklist-for-committers. -->
### Description
<!-- Describe the goal of this PR, what problem are you fixing. If there is a corresponding issue (referenced above), it's not necessary to repeat the description here, however, you may choose to keep one summary sentence. -->
<!-- Describe your patch: what did you change in code? How did you fix the problem? -->
<!-- If there are several relatively logically separate changes in this PR, create a mini-section for each of them. For example: -->
#### Fixed the bug ...
#### Renamed the class ...
#### Added a forbidden-apis entry ...
<!--
In each section, please describe design decisions made, including:
- Choice of algorithms
- Behavioral aspects. What configuration values are acceptable? How are corner cases and error conditions handled, such as when there are insufficient resources?
- Class organization and design (how the logic is split between classes, inheritance, composition, design patterns)
- Method organization and design (how the logic is split between methods, parameters and return types)
- Naming (class, method, API, configuration, HTTP endpoint, names of emitted metrics)
-->
<!-- It's good to describe an alternative design (or mention an alternative name) for every design (or naming) decision point and compare the alternatives with the designs that you've implemented (or the names you've chosen) to highlight the advantages of the chosen designs and names. -->
<!-- If there was a discussion of the design of the feature implemented in this PR elsewhere (e. g. a "Proposal" issue, any other issue, or a thread in the development mailing list), link to that discussion from this PR description and explain what have changed in your final design compared to your original proposal or the consensus version in the end of the discussion. If something hasn't changed since the original discussion, you can omit a detailed discussion of those aspects of the design here, perhaps apart from brief mentioning for the sake of readability of this PR description. -->
<!-- Some of the aspects mentioned above may be omitted for simple and small changes. -->
<hr>
##### Key changed/added classes in this PR
* `MyFoo`
* `OurBar`
* `TheirBaz`
<hr>
<!-- Check the items by putting "x" in the brackets for the done things. Not all of these items apply to every PR. Remove the items which are not done or not relevant to the PR. None of the items from the checklist below are strictly necessary, but it would be very helpful if you at least self-review the PR. -->
This PR has:
- [ ] been self-reviewed.
- [ ] using the [concurrency checklist](https://github.com/apache/druid/blob/master/dev/code-review/concurrency.md) (Remove this item if the PR doesn't have any relation to concurrency.)
- [ ] added documentation for new or modified features or behaviors.
- [ ] added Javadocs for most classes and all non-trivial methods. Linked related entities via Javadoc links.
- [ ] added or updated version, license, or notice information in [licenses.yaml](https://github.com/apache/druid/blob/master/dev/license.md)
- [ ] added comments explaining the "why" and the intent of the code wherever would not be obvious for an unfamiliar reader.
- [ ] added unit tests or modified existing tests to cover new code paths, ensuring the threshold for [code coverage](https://github.com/apache/druid/blob/master/dev/code-review/code-coverage.md) is met.
- [ ] added integration tests.
- [ ] been tested in a test Druid cluster.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r666623991
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
+ {
+ if (partitionsSpec != null) {
+ return partitionsSpec;
+ }
+ return forceGuaranteedRollup
+ ? new HashedPartitionsSpec(null, null, null)
+ : new DynamicPartitionsSpec(null, null);
+ }
+
+ @Override
+ public IndexSpec getIndexSpec()
+ {
+ return indexSpec;
+ }
+
+ @Override
+ public IndexSpec getIndexSpecForIntermediatePersists()
+ {
+ return indexSpecForIntermediatePersists;
+ }
+
+ @Override
+ public int getMaxPendingPersists()
+ {
+ return maxPendingPersists;
+ }
+
+ public boolean isForceGuaranteedRollup()
+ {
+ return forceGuaranteedRollup;
+ }
+
+ @Override
+ public boolean isReportParseExceptions()
+ {
+ return reportParseExceptions;
+ }
+
+ @Nullable
+ @Override
+ public SegmentWriteOutMediumFactory getSegmentWriteOutMediumFactory()
+ {
+ return segmentWriteOutMediumFactory;
+ }
+
+ @Override
+ public int getMaxColumnsToMerge()
+ {
+ return maxColumnsToMerge;
+ }
+
+ public boolean isLogParseExceptions()
+ {
+ return logParseExceptions;
+ }
+
+ public int getMaxParseExceptions()
+ {
+ return maxParseExceptions;
+ }
+
+ public int getMaxSavedParseExceptions()
+ {
+ return maxSavedParseExceptions;
+ }
+
+ /**
+ * Return the max number of rows per segment. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Nullable
+ @Override
+ @Deprecated
Review comment:
Fixed
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] jihoonson commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
jihoonson commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r665812457
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,859 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.column.ColumnConfig;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean batchFallback
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new IndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null
+ ).withBasePersistDirectory(basePersistDirectory != null ? basePersistDirectory : createNewBasePersistDirectory());
+
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ new ColumnConfig()
+ {
+ @Override
+ public int columnCacheSizeBytes()
+ {
+ return 0;
+ }
+ }
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ batchFallback
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing as is for testing since it is not accessible from server module,
+ // we could simplify since not all its functionality is being used
+ // but leaving as is, it could be useful later
+ private static class IndexTuningConfig implements AppenderatorConfig
Review comment:
I don't agree that it's already simple enough. Why is it Jackson-serializable? It doesn't seem to be used in any test. Besides this, I also see lots of methods and parameters deprecated, not in use at all, or not used in any test. I can leave comments on them to help you identify them if you want. I don't think we should keep this code if the reason is just that we might need them in the future. It will be easy to add them back if we need, or we can do even better than now.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r661903742
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ return null;
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrant();
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, false);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed());
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData)
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ // Drop everything.
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), removeOnDiskData);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ removeSink(identifier, sink, true);
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ private void persistAllAndClear()
+ {
+ // make sure sinks are cleared before push is called
+ try {
+ persistAll(null).get();
+ clear(false);
+ }
+ catch (Throwable t) {
+ throw new RE(t, "Error while persisting");
+ }
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .filter(itp -> itp.rhs != null)
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ persistAllAndClear();
+
+ log.info("Preparing to push...");
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ if (persistedIdentifiers == null) {
+ throw new ISE("Identifiers were persisted but could not be retrieved");
+ }
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks;
+ try {
+ identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ }
+ catch (IOException e) {
+ throw new ISE(e, "Failed to retrieve sinks for identifier", identifier);
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658479096
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderator.java
##########
@@ -235,7 +238,7 @@ AppenderatorAddResult add(
private final int numRowsInSegment;
private final boolean isPersistRequired;
- AppenderatorAddResult(
+ public AppenderatorAddResult(
Review comment:
Changed back visibility to package only.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658491355
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r664796164
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+ /* Reference to directory that holds the persisted data */
+ File persistedFileDir;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ public void setPersistedFileDir(File persistedFileDir)
+ {
+ this.persistedFileDir = persistedFileDir;
+ }
+
+ public File getPersistedFileDir()
+ {
+ return persistedFileDir;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ return null;
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrant();
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndRemoveSinks();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, false);
+ }
+
+ @Override
+ /**
+ * Returns all active segments regardless whether they are in memory or persisted
+ */
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinksMetadata.keySet());
+ }
+
+ @VisibleForTesting
+ public List<SegmentIdWithShardSpec> getInMemorySegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed());
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear()
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData)
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ // Drop everything.
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), removeOnDiskData);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ removeSink(identifier, sink, true);
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ if (committer != null) {
+ throw new ISE("committer must be null for BatchAppenderator");
+ }
+ persistAllAndRemoveSinks();
+ return Futures.immediateFuture(null);
+ }
+
+ /**
+ * Persist all sinks & their hydrants, keep their metadata, and then remove them completely from
+ * memory (to be resurrected right before merge & push)
+ */
+ private void persistAllAndRemoveSinks()
+ {
+
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ int totalHydrantsCount = 0;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ // Since everytime we persist we also get rid of the in-memory references to sinks & hydrants
+ // the invariant of exactly one, always swappable, sink with exactly one unpersisted hydrant must hold
+ int totalHydrantsForSink = hydrants.size();
+ if (totalHydrantsForSink != 1) {
+ throw new ISE("There should be only onw hydrant for identifier[%s] but there are[%s]",
+ identifier, totalHydrantsForSink
+ );
+ }
+ totalHydrantsCount += 1;
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ if (!sink.swappable()) {
+ throw new ISE("Sink is not swappable![%s]", identifier);
+ }
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+
+ }
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .filter(itp -> itp.rhs != null)
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], persisted sinks: [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ numPersistedRows,
+ totalSinks,
+ totalHydrantsCount
+ );
+
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ // remove all sinks after persisting:
+ clear(false);
+
+ log.info("Persisted rows[%,d] and bytes[%,d] and removed all sinks & hydrants from memory",
+ numPersistedRows, bytesPersisted);
+
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ if (useUniquePath) {
+ throw new ISE("Batch ingestion does not require uniquePath");
+ }
+
+
+ // Any sinks not persisted so far need to be persisted before push:
+ persistAllAndRemoveSinks();
+
+ log.info("Preparing to push...");
+
+ // get the dirs for the identfiers:
+ List<File> identifiersDirs = new ArrayList<>();
+ for (SegmentIdWithShardSpec identifier : identifiers) {
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ throw new ISE("No sink has been processed for identifier[%s]", identifier);
+ }
+ File persistedDir = sm.getPersistedFileDir();
+ if (persistedDir == null) {
+ throw new ISE("Sink for identifier[%s] not found in local file system", identifier);
+ }
+ identifiersDirs.add(persistedDir);
+ }
+
+ // push all sinks for identifiers:
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ for (File identifier : identifiersDirs) {
+
+ // retrieve sink from disk:
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks;
+ try {
+ identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ }
+ catch (IOException e) {
+ throw new ISE(e, "Failed to retrieve sinks for identifier[%s]", identifier);
+ }
+
+ // push it:
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ false
+ );
+
+ // record it:
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+
+ }
+ log.info("Push complete...");
+
+ return Futures.immediateFuture(new SegmentsAndCommitMetadata(dataSegments, null));
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r664796793
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+ /* Reference to directory that holds the persisted data */
+ File persistedFileDir;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ public void setPersistedFileDir(File persistedFileDir)
+ {
+ this.persistedFileDir = persistedFileDir;
+ }
+
+ public File getPersistedFileDir()
+ {
+ return persistedFileDir;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ return null;
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrant();
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndRemoveSinks();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, false);
+ }
+
+ @Override
+ /**
+ * Returns all active segments regardless whether they are in memory or persisted
+ */
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinksMetadata.keySet());
+ }
+
+ @VisibleForTesting
+ public List<SegmentIdWithShardSpec> getInMemorySegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed());
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear()
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData)
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ // Drop everything.
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), removeOnDiskData);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ removeSink(identifier, sink, true);
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ if (committer != null) {
+ throw new ISE("committer must be null for BatchAppenderator");
+ }
+ persistAllAndRemoveSinks();
+ return Futures.immediateFuture(null);
+ }
+
+ /**
+ * Persist all sinks & their hydrants, keep their metadata, and then remove them completely from
+ * memory (to be resurrected right before merge & push)
+ */
+ private void persistAllAndRemoveSinks()
+ {
+
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ int totalHydrantsCount = 0;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ // Since everytime we persist we also get rid of the in-memory references to sinks & hydrants
+ // the invariant of exactly one, always swappable, sink with exactly one unpersisted hydrant must hold
+ int totalHydrantsForSink = hydrants.size();
+ if (totalHydrantsForSink != 1) {
+ throw new ISE("There should be only onw hydrant for identifier[%s] but there are[%s]",
+ identifier, totalHydrantsForSink
+ );
+ }
+ totalHydrantsCount += 1;
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ if (!sink.swappable()) {
+ throw new ISE("Sink is not swappable![%s]", identifier);
+ }
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+
+ }
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .filter(itp -> itp.rhs != null)
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], persisted sinks: [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ numPersistedRows,
+ totalSinks,
+ totalHydrantsCount
+ );
+
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ // remove all sinks after persisting:
+ clear(false);
+
+ log.info("Persisted rows[%,d] and bytes[%,d] and removed all sinks & hydrants from memory",
+ numPersistedRows, bytesPersisted);
+
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ if (useUniquePath) {
+ throw new ISE("Batch ingestion does not require uniquePath");
+ }
+
+
+ // Any sinks not persisted so far need to be persisted before push:
+ persistAllAndRemoveSinks();
+
+ log.info("Preparing to push...");
+
+ // get the dirs for the identfiers:
+ List<File> identifiersDirs = new ArrayList<>();
+ for (SegmentIdWithShardSpec identifier : identifiers) {
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ throw new ISE("No sink has been processed for identifier[%s]", identifier);
+ }
+ File persistedDir = sm.getPersistedFileDir();
+ if (persistedDir == null) {
+ throw new ISE("Sink for identifier[%s] not found in local file system", identifier);
+ }
+ identifiersDirs.add(persistedDir);
+ }
+
+ // push all sinks for identifiers:
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ for (File identifier : identifiersDirs) {
+
+ // retrieve sink from disk:
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks;
+ try {
+ identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ }
+ catch (IOException e) {
+ throw new ISE(e, "Failed to retrieve sinks for identifier[%s]", identifier);
+ }
+
+ // push it:
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ false
+ );
+
+ // record it:
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+
+ }
+ log.info("Push complete...");
+
+ return Futures.immediateFuture(new SegmentsAndCommitMetadata(dataSegments, null));
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sm.getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sm.getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+ if (useUniquePath) {
+ throw new ISE("Merge and push for batch appenderator does not use unique path");
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // This appenderator is used only for the local indexing task so unique paths are not required
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), false);
+ }
+
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ if (persistedIdentifiers != null) {
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ Nothing to do since there are no executors
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @VisibleForTesting
+ @Nullable
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ private Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ throws IOException
+ {
+
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, IDENTIFIER_FILE_NAME),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+ if (sinkFiles == null) {
+ throw new ISE("Problem reading persisted sinks in path[%s]", identifierPath);
+ }
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ return new Pair<>(identifier, currSink);
+ }
+
+ private void removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed());
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrant());
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ if (removeOnDiskData) {
+ removeDirectory(computePersistDir(identifier));
+ }
+
+ log.info("Removed sink for segment[%s].", identifier);
+
+ }
+
+ private File computeLockFile()
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), ".lock");
+ }
+
+ private File computePersistDir(SegmentIdWithShardSpec identifier)
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
+ }
+
+ private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
+ }
+
+ private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), "descriptor.json");
+ }
+
+ private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
+ {
+ final File persistDir = computePersistDir(identifier);
+ org.apache.commons.io.FileUtils.forceMkdir(persistDir);
+
+ objectMapper.writeValue(computeIdentifierFile(identifier), identifier);
+
+ return persistDir;
+ }
+
+ /**
+ * Persists the given hydrant and returns the number of rows persisted.
+ *
+ * @param indexToPersist hydrant to persist
+ * @param identifier the segment this hydrant is going to be part of
+ * @return the number of rows persisted
+ */
+ private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
+ {
+ synchronized (indexToPersist) {
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r664966887
##########
File path: docs/configuration/index.md
##########
@@ -1334,7 +1334,7 @@ Additional peon configs include:
|`druid.peon.mode`|Choices are "local" and "remote". Setting this to local means you intend to run the peon as a standalone process (Not recommended).|remote|
|`druid.indexer.task.baseDir`|Base temporary working directory.|`System.getProperty("java.io.tmpdir")`|
|`druid.indexer.task.baseTaskDir`|Base temporary working directory for tasks.|`${druid.indexer.task.baseDir}/persistent/task`|
-|`druid.indexer.task.batchMemoryMappedIndex`|If false, native batch ingestion will not map indexes thus saving heap space. This does not apply to streaming ingestion, just to batch. This setting should only be used when a bug is suspected or found in the new batch ingestion code that avoids memory mapping indices. If a bug is suspected or found, you can set this flag to `true` to fall back to previous, working but more memory intensive, code path.|`false`|
+|`druid.indexer.task.batchFallback`|If false, native batch ingestion will use memory optimized code. This does not apply to streaming ingestion, just to batch. This setting should only be used when a bug is suspected or found in the new optimized batch ingestion code. If a bug is suspected or found, you can set this flag to `true` to fall back to previous, working but more memory intensive, code path.|`false`|
Review comment:
I intentionally left that variable with a vague name...if the previous that I just removed would have had a vague name like that then I could have just re-used it and maybe edit the description in the docs. I feel this name is fine (I accept it is vague--which is intentional) since it is really there for an exceptional situation. We want to get rid of this asap, potentially before the next open source release.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658528374
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
Review comment:
Cleaned up...it always returns null metadata
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] jihoonson commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
jihoonson commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r659087724
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -764,7 +691,7 @@ private DataSegment mergeAndPush(
SinkMetadata sm = sinksMetadata.get(identifier);
if (sm == null) {
log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
- } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ } else if (numHydrants != sm.getNumHydrants()) {
throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
Review comment:
This should use `sm` too because `sinksMetadata.get(identifier)` can return null if `drop()` is called for some reason after you get `sm above.
```suggestion
numHydrants, identifier, sm.getNumHydrants());
```
##########
File path: indexing-service/src/test/java/org/apache/druid/indexing/appenderator/BatchAppenderatorDriverTest.java
##########
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.druid.segment.realtime.appenderator;
+package org.apache.druid.indexing.appenderator;
Review comment:
The way the coverage bot works currently is running all tests and finding the lines and branches in the corresponding classes to those tests. One requirement is that the target class to test and its test class must be in the same package. So, I would suggest not moving this class if possible because you will need to move lots of other classes along with it.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
Review comment:
This parameter must be always null per the argument checker below.. Can we just remove it?
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -604,48 +557,39 @@ private SegmentsAndCommitMetadata persistAllAndClear()
final Stopwatch runExecStopwatch = Stopwatch.createStarted();
final Stopwatch persistStopwatch = Stopwatch.createStarted();
AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
- final ListenableFuture<Object> future = persistExecutor.submit(
- new Callable<Object>()
- {
- @Override
- public Object call()
- {
- try {
- for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
- metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
- }
-
- log.info(
- "Persisted in-memory data for segments: %s",
- indexesToPersist.stream()
- .map(itp -> itp.rhs.asSegmentId().toString())
- .distinct()
- .collect(Collectors.joining(", "))
- );
- log.info(
- "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
- rowIngestionMeters.getProcessed(),
- totalPersistedRows.get(),
- totalSinks,
- totalHydrantsCount.longValue(),
- totalHydrantsPersistedAcrossSinks.longValue()
- );
-
- // return null if committer is null
- return null;
- }
- catch (Exception e) {
- metrics.incrementFailedPersists();
- throw e;
- }
- finally {
- metrics.incrementNumPersists();
- metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
- persistStopwatch.stop();
- }
- }
- }
- );
+
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .filter(itp -> itp.rhs != null)
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
metrics.incrementPersistBackPressureMillis(startDelay);
Review comment:
This will report a wrong metric because there is no start delay now. I think we don't have to report it since we don't use the executor anymore. You can remove `runExecStopwatch` too.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ return null;
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrant();
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, false);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed());
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData)
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ // Drop everything.
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), removeOnDiskData);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ removeSink(identifier, sink, true);
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ private void persistAllAndClear()
+ {
+ // make sure sinks are cleared before push is called
+ try {
+ persistAll(null).get();
+ clear(false);
+ }
+ catch (Throwable t) {
+ throw new RE(t, "Error while persisting");
+ }
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .filter(itp -> itp.rhs != null)
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ persistAllAndClear();
+
+ log.info("Preparing to push...");
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ if (persistedIdentifiers == null) {
+ throw new ISE("Identifiers were persisted but could not be retrieved");
+ }
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks;
+ try {
+ identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ }
+ catch (IOException e) {
+ throw new ISE(e, "Failed to retrieve sinks for identifier", identifier);
+ }
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+ log.info("Push complete...");
+
+ return Futures.immediateFuture(new SegmentsAndCommitMetadata(dataSegments, null));
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sm.getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), false);
+ }
+
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ if (persistedIdentifiers != null) {
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ Nothing to do since there are no executors
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @VisibleForTesting
+ @Nullable
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ private Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ throws IOException
+ {
+
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, IDENTIFIER_FILE_NAME),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+ if (sinkFiles == null) {
+ throw new ISE("Problem reading persisted sinks in path", identifierPath);
+ }
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ return new Pair<>(identifier, currSink);
+ }
+
+ private void removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed());
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrant());
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ if (removeOnDiskData) {
+ removeDirectory(computePersistDir(identifier));
+ }
+
+ log.info("Removed sink for segment[%s].", identifier);
+
+ }
+
+ private File computeLockFile()
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), ".lock");
+ }
+
+ private File computePersistDir(SegmentIdWithShardSpec identifier)
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
+ }
+
+ private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
+ }
+
+ private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), "descriptor.json");
+ }
+
+ private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
+ {
+ final File persistDir = computePersistDir(identifier);
+ org.apache.commons.io.FileUtils.forceMkdir(persistDir);
+
+ objectMapper.writeValue(computeIdentifierFile(identifier), identifier);
+
+ return persistDir;
+ }
+
+ /**
+ * Persists the given hydrant and returns the number of rows persisted.
+ *
+ * @param indexToPersist hydrant to persist
+ * @param identifier the segment this hydrant is going to be part of
+ * @return the number of rows persisted
+ */
+ private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
+ {
+ synchronized (indexToPersist) {
+ if (indexToPersist.hasSwapped()) {
+ log.info(
+ "Segment[%s] hydrant[%s] already swapped. Ignoring request to persist.",
+ identifier,
+ indexToPersist
+ );
+ return 0;
+ }
+
+ log.debug("Segment[%s], persisting Hydrant[%s]", identifier, indexToPersist);
+
+ try {
+ final long startTime = System.nanoTime();
+ int numRows = indexToPersist.getIndex().size();
+
+ // since the sink may have been persisted before it may have lost its
+ // hydrant count, we remember that value in the sinks metadata so we have
+ // to pull it from there....
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ throw new ISE("Sink must not be null for identifier when persisting hydrant", identifier);
Review comment:
```suggestion
throw new ISE("Sink must not be null for identifier[%s] when persisting hydrant", identifier);
```
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java
##########
@@ -172,7 +172,7 @@ SegmentWithState getAppendingSegment()
/**
* Allocated segments for a sequence
*/
- static class SegmentsForSequence
+ public static class SegmentsForSequence
Review comment:
`BatchAppenderatorDriver` is in the same package as `BaseAppenderatorDriver`. I assume you meant `BatchAppenderatorDriverTest` which is the class you moved to another package. As I said in my other comment, the class to test and its corresponding test class should be in the same package to help the test coverage bot. I suggested to not move the package of `BatchAppenderatorDriverTest` and thus you will not need to change this access modifier either. Same for other access modifier changes in this class.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
Review comment:
This javadoc is no longer correct. I think you can simply delete it.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ return null;
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrant();
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, false);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed());
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData)
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ // Drop everything.
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), removeOnDiskData);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ removeSink(identifier, sink, true);
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ private void persistAllAndClear()
+ {
+ // make sure sinks are cleared before push is called
+ try {
+ persistAll(null).get();
+ clear(false);
+ }
+ catch (Throwable t) {
+ throw new RE(t, "Error while persisting");
+ }
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .filter(itp -> itp.rhs != null)
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ persistAllAndClear();
+
+ log.info("Preparing to push...");
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ if (persistedIdentifiers == null) {
+ throw new ISE("Identifiers were persisted but could not be retrieved");
+ }
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks;
+ try {
+ identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ }
+ catch (IOException e) {
+ throw new ISE(e, "Failed to retrieve sinks for identifier", identifier);
Review comment:
```suggestion
throw new ISE(e, "Failed to retrieve sinks for identifier[%s]", identifier);
```
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ return null;
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrant();
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, false);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed());
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData)
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ // Drop everything.
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), removeOnDiskData);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ removeSink(identifier, sink, true);
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ private void persistAllAndClear()
+ {
+ // make sure sinks are cleared before push is called
+ try {
+ persistAll(null).get();
+ clear(false);
+ }
+ catch (Throwable t) {
+ throw new RE(t, "Error while persisting");
+ }
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .filter(itp -> itp.rhs != null)
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ persistAllAndClear();
+
+ log.info("Preparing to push...");
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ if (persistedIdentifiers == null) {
+ throw new ISE("Identifiers were persisted but could not be retrieved");
+ }
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks;
+ try {
+ identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ }
+ catch (IOException e) {
+ throw new ISE(e, "Failed to retrieve sinks for identifier", identifier);
+ }
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+ log.info("Push complete...");
+
+ return Futures.immediateFuture(new SegmentsAndCommitMetadata(dataSegments, null));
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sm.getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), false);
+ }
+
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ if (persistedIdentifiers != null) {
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ Nothing to do since there are no executors
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @VisibleForTesting
+ @Nullable
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ private Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ throws IOException
+ {
+
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, IDENTIFIER_FILE_NAME),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+ if (sinkFiles == null) {
+ throw new ISE("Problem reading persisted sinks in path", identifierPath);
Review comment:
```suggestion
throw new ISE("Problem reading persisted sinks in path[%s]", identifierPath);
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r662539405
##########
File path: indexing-service/src/test/java/org/apache/druid/indexing/appenderator/BatchAppenderatorDriverTest.java
##########
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.druid.segment.realtime.appenderator;
+package org.apache.druid.indexing.appenderator;
Review comment:
I am excluding the class again.. I see no easy way to moving them all to the same package. We are fighting against a tool (coverage) primarily, secondarily against module design (i.e. "server" has some batch stuff and it should only have "realtime" stuff). Resolving the latter, which takes non-trivial effort and should go in another ticket, will also resolve the former.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] lgtm-com[bot] commented on pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
lgtm-com[bot] commented on pull request #11294:
URL: https://github.com/apache/druid/pull/11294#issuecomment-873308120
This pull request **introduces 2 alerts** when merging 62e4ac30e8ae085c4da3b5869333f6fba090677e into a9c4b478ab7f992d8eeafa3703daff46a72d5812 - [view on LGTM.com](https://lgtm.com/projects/g/apache/druid/rev/pr-2f48b0d20791106e4761a8d91192ee2b4bb65dad)
**new alerts:**
* 1 for Missing format argument
* 1 for Useless null check
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658474991
##########
File path: indexing-service/src/test/java/org/apache/druid/indexing/appenderator/BatchAppenderatorDriverTest.java
##########
@@ -199,4 +209,40 @@ static TransactionalSegmentPublisher makeOkPublisher()
{
return (segmentsToBeOverwritten, segmentsToBeDropped, segmentsToPublish, commitMetadata) -> SegmentPublishResult.ok(ImmutableSet.of());
}
+
+ static class TestSegmentAllocator implements SegmentAllocator
+ {
+ private final String dataSource;
+ private final Granularity granularity;
+ private final Map<Long, AtomicInteger> counters = new HashMap<>();
+
+ public TestSegmentAllocator(String dataSource, Granularity granularity)
+ {
+ this.dataSource = dataSource;
+ this.granularity = granularity;
+ }
+
+ @Override
+ public SegmentIdWithShardSpec allocate(
+ final InputRow row,
+ final String sequenceName,
+ final String previousSegmentId,
+ final boolean skipSegmentLineageCheck
+ )
+ {
+ synchronized (counters) {
Review comment:
Removed synchronized block
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] jihoonson commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
jihoonson commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r666498869
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
Review comment:
PartitionsSpec in this class is not in use any test. Please stop copying the business logic to the test. All tests must pass a proper partitionsSpec if they test partitioning-related behavior unless they verify the default partitionsSpec.
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
Review comment:
Many parameters including this are deprecated in `IndexTuningConfig`. They only exist in `IndexTuningConfig` for compatibility. It doesn't seem reasonable to copy them to here.
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
Review comment:
This method is not in use.
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
+ {
+ if (partitionsSpec != null) {
+ return partitionsSpec;
+ }
+ return forceGuaranteedRollup
+ ? new HashedPartitionsSpec(null, null, null)
+ : new DynamicPartitionsSpec(null, null);
+ }
+
+ @Override
+ public IndexSpec getIndexSpec()
+ {
+ return indexSpec;
+ }
+
+ @Override
+ public IndexSpec getIndexSpecForIntermediatePersists()
+ {
+ return indexSpecForIntermediatePersists;
+ }
+
+ @Override
+ public int getMaxPendingPersists()
+ {
+ return maxPendingPersists;
+ }
+
+ public boolean isForceGuaranteedRollup()
+ {
+ return forceGuaranteedRollup;
+ }
+
+ @Override
+ public boolean isReportParseExceptions()
+ {
+ return reportParseExceptions;
+ }
+
+ @Nullable
+ @Override
+ public SegmentWriteOutMediumFactory getSegmentWriteOutMediumFactory()
+ {
+ return segmentWriteOutMediumFactory;
+ }
+
+ @Override
+ public int getMaxColumnsToMerge()
+ {
+ return maxColumnsToMerge;
+ }
+
+ public boolean isLogParseExceptions()
+ {
+ return logParseExceptions;
+ }
+
+ public int getMaxParseExceptions()
+ {
+ return maxParseExceptions;
+ }
+
+ public int getMaxSavedParseExceptions()
+ {
+ return maxSavedParseExceptions;
+ }
+
+ /**
+ * Return the max number of rows per segment. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Nullable
+ @Override
+ @Deprecated
+ public Integer getMaxRowsPerSegment()
+ {
+ return partitionsSpec == null ? null : partitionsSpec.getMaxRowsPerSegment();
+ }
+
+ /**
+ * Return the max number of total rows in appenderator. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Override
+ @Nullable
+ @Deprecated
+ public Long getMaxTotalRows()
+ {
+ return partitionsSpec instanceof DynamicPartitionsSpec
+ ? ((DynamicPartitionsSpec) partitionsSpec).getMaxTotalRows()
+ : null;
+ }
+
+ @Deprecated
+ @Nullable
+ public Integer getNumShards()
+ {
+ return partitionsSpec instanceof HashedPartitionsSpec
+ ? ((HashedPartitionsSpec) partitionsSpec).getNumShards()
+ : null;
+ }
+
+ @Deprecated
+ public List<String> getPartitionDimensions()
Review comment:
Same here. Why do you want to add a deprecated method?
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
+ {
+ if (partitionsSpec != null) {
+ return partitionsSpec;
+ }
+ return forceGuaranteedRollup
+ ? new HashedPartitionsSpec(null, null, null)
+ : new DynamicPartitionsSpec(null, null);
+ }
+
+ @Override
+ public IndexSpec getIndexSpec()
+ {
+ return indexSpec;
+ }
+
+ @Override
+ public IndexSpec getIndexSpecForIntermediatePersists()
+ {
+ return indexSpecForIntermediatePersists;
+ }
+
+ @Override
+ public int getMaxPendingPersists()
+ {
+ return maxPendingPersists;
+ }
+
+ public boolean isForceGuaranteedRollup()
+ {
+ return forceGuaranteedRollup;
+ }
+
+ @Override
+ public boolean isReportParseExceptions()
+ {
+ return reportParseExceptions;
+ }
+
+ @Nullable
+ @Override
+ public SegmentWriteOutMediumFactory getSegmentWriteOutMediumFactory()
+ {
+ return segmentWriteOutMediumFactory;
+ }
+
+ @Override
+ public int getMaxColumnsToMerge()
+ {
+ return maxColumnsToMerge;
+ }
+
+ public boolean isLogParseExceptions()
+ {
+ return logParseExceptions;
+ }
+
+ public int getMaxParseExceptions()
+ {
+ return maxParseExceptions;
+ }
+
+ public int getMaxSavedParseExceptions()
+ {
+ return maxSavedParseExceptions;
+ }
Review comment:
These methods are not in use.
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
+ {
+ if (partitionsSpec != null) {
+ return partitionsSpec;
+ }
+ return forceGuaranteedRollup
+ ? new HashedPartitionsSpec(null, null, null)
+ : new DynamicPartitionsSpec(null, null);
+ }
+
+ @Override
+ public IndexSpec getIndexSpec()
+ {
+ return indexSpec;
+ }
+
+ @Override
+ public IndexSpec getIndexSpecForIntermediatePersists()
+ {
+ return indexSpecForIntermediatePersists;
+ }
+
+ @Override
+ public int getMaxPendingPersists()
+ {
+ return maxPendingPersists;
+ }
+
+ public boolean isForceGuaranteedRollup()
+ {
+ return forceGuaranteedRollup;
+ }
+
+ @Override
+ public boolean isReportParseExceptions()
+ {
+ return reportParseExceptions;
+ }
+
+ @Nullable
+ @Override
+ public SegmentWriteOutMediumFactory getSegmentWriteOutMediumFactory()
+ {
+ return segmentWriteOutMediumFactory;
+ }
+
+ @Override
+ public int getMaxColumnsToMerge()
+ {
+ return maxColumnsToMerge;
+ }
+
+ public boolean isLogParseExceptions()
+ {
+ return logParseExceptions;
+ }
+
+ public int getMaxParseExceptions()
+ {
+ return maxParseExceptions;
+ }
+
+ public int getMaxSavedParseExceptions()
+ {
+ return maxSavedParseExceptions;
+ }
+
+ /**
+ * Return the max number of rows per segment. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Nullable
+ @Override
+ @Deprecated
+ public Integer getMaxRowsPerSegment()
+ {
+ return partitionsSpec == null ? null : partitionsSpec.getMaxRowsPerSegment();
+ }
+
+ /**
+ * Return the max number of total rows in appenderator. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Override
+ @Nullable
+ @Deprecated
+ public Long getMaxTotalRows()
+ {
+ return partitionsSpec instanceof DynamicPartitionsSpec
+ ? ((DynamicPartitionsSpec) partitionsSpec).getMaxTotalRows()
+ : null;
+ }
+
+ @Deprecated
+ @Nullable
+ public Integer getNumShards()
+ {
+ return partitionsSpec instanceof HashedPartitionsSpec
+ ? ((HashedPartitionsSpec) partitionsSpec).getNumShards()
+ : null;
+ }
+
+ @Deprecated
+ public List<String> getPartitionDimensions()
+ {
+ return partitionsSpec instanceof HashedPartitionsSpec
+ ? ((HashedPartitionsSpec) partitionsSpec).getPartitionDimensions()
+ : Collections.emptyList();
+ }
+
+ @Override
+ public File getBasePersistDirectory()
+ {
+ return basePersistDirectory;
+ }
+
+ @Override
+ public Period getIntermediatePersistPeriod()
+ {
+ return new Period(Integer.MAX_VALUE); // intermediate persist doesn't make much sense for batch jobs
+ }
+
+
+ public long getAwaitSegmentAvailabilityTimeoutMillis()
Review comment:
This method is not in use.
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
+ {
+ if (partitionsSpec != null) {
+ return partitionsSpec;
+ }
+ return forceGuaranteedRollup
+ ? new HashedPartitionsSpec(null, null, null)
+ : new DynamicPartitionsSpec(null, null);
+ }
+
+ @Override
+ public IndexSpec getIndexSpec()
+ {
+ return indexSpec;
+ }
+
+ @Override
+ public IndexSpec getIndexSpecForIntermediatePersists()
+ {
+ return indexSpecForIntermediatePersists;
+ }
+
+ @Override
+ public int getMaxPendingPersists()
+ {
+ return maxPendingPersists;
+ }
+
+ public boolean isForceGuaranteedRollup()
+ {
+ return forceGuaranteedRollup;
+ }
+
+ @Override
+ public boolean isReportParseExceptions()
+ {
+ return reportParseExceptions;
+ }
+
+ @Nullable
+ @Override
+ public SegmentWriteOutMediumFactory getSegmentWriteOutMediumFactory()
+ {
+ return segmentWriteOutMediumFactory;
+ }
+
+ @Override
+ public int getMaxColumnsToMerge()
+ {
+ return maxColumnsToMerge;
+ }
+
+ public boolean isLogParseExceptions()
+ {
+ return logParseExceptions;
+ }
+
+ public int getMaxParseExceptions()
+ {
+ return maxParseExceptions;
+ }
+
+ public int getMaxSavedParseExceptions()
+ {
+ return maxSavedParseExceptions;
+ }
+
+ /**
+ * Return the max number of rows per segment. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Nullable
+ @Override
+ @Deprecated
Review comment:
This method is not deprecated.
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
+ {
+ if (partitionsSpec != null) {
+ return partitionsSpec;
+ }
+ return forceGuaranteedRollup
+ ? new HashedPartitionsSpec(null, null, null)
+ : new DynamicPartitionsSpec(null, null);
+ }
+
+ @Override
+ public IndexSpec getIndexSpec()
+ {
+ return indexSpec;
+ }
+
+ @Override
+ public IndexSpec getIndexSpecForIntermediatePersists()
+ {
+ return indexSpecForIntermediatePersists;
+ }
+
+ @Override
+ public int getMaxPendingPersists()
+ {
+ return maxPendingPersists;
+ }
+
+ public boolean isForceGuaranteedRollup()
Review comment:
This method is not in use.
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
+ {
+ if (partitionsSpec != null) {
+ return partitionsSpec;
+ }
+ return forceGuaranteedRollup
+ ? new HashedPartitionsSpec(null, null, null)
+ : new DynamicPartitionsSpec(null, null);
+ }
+
+ @Override
+ public IndexSpec getIndexSpec()
+ {
+ return indexSpec;
+ }
+
+ @Override
+ public IndexSpec getIndexSpecForIntermediatePersists()
+ {
+ return indexSpecForIntermediatePersists;
+ }
+
+ @Override
+ public int getMaxPendingPersists()
+ {
+ return maxPendingPersists;
+ }
+
+ public boolean isForceGuaranteedRollup()
+ {
+ return forceGuaranteedRollup;
+ }
+
+ @Override
+ public boolean isReportParseExceptions()
+ {
+ return reportParseExceptions;
+ }
+
+ @Nullable
+ @Override
+ public SegmentWriteOutMediumFactory getSegmentWriteOutMediumFactory()
+ {
+ return segmentWriteOutMediumFactory;
+ }
+
+ @Override
+ public int getMaxColumnsToMerge()
+ {
+ return maxColumnsToMerge;
+ }
+
+ public boolean isLogParseExceptions()
+ {
+ return logParseExceptions;
+ }
+
+ public int getMaxParseExceptions()
+ {
+ return maxParseExceptions;
+ }
+
+ public int getMaxSavedParseExceptions()
+ {
+ return maxSavedParseExceptions;
+ }
+
+ /**
+ * Return the max number of rows per segment. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Nullable
+ @Override
+ @Deprecated
+ public Integer getMaxRowsPerSegment()
+ {
+ return partitionsSpec == null ? null : partitionsSpec.getMaxRowsPerSegment();
+ }
+
+ /**
+ * Return the max number of total rows in appenderator. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Override
+ @Nullable
+ @Deprecated
Review comment:
This method is not deprecated.
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
+ {
+ if (partitionsSpec != null) {
+ return partitionsSpec;
+ }
+ return forceGuaranteedRollup
+ ? new HashedPartitionsSpec(null, null, null)
+ : new DynamicPartitionsSpec(null, null);
+ }
+
+ @Override
+ public IndexSpec getIndexSpec()
+ {
+ return indexSpec;
+ }
+
+ @Override
+ public IndexSpec getIndexSpecForIntermediatePersists()
+ {
+ return indexSpecForIntermediatePersists;
+ }
+
+ @Override
+ public int getMaxPendingPersists()
+ {
+ return maxPendingPersists;
+ }
+
+ public boolean isForceGuaranteedRollup()
+ {
+ return forceGuaranteedRollup;
+ }
+
+ @Override
+ public boolean isReportParseExceptions()
+ {
+ return reportParseExceptions;
+ }
+
+ @Nullable
+ @Override
+ public SegmentWriteOutMediumFactory getSegmentWriteOutMediumFactory()
+ {
+ return segmentWriteOutMediumFactory;
+ }
+
+ @Override
+ public int getMaxColumnsToMerge()
+ {
+ return maxColumnsToMerge;
+ }
+
+ public boolean isLogParseExceptions()
+ {
+ return logParseExceptions;
+ }
+
+ public int getMaxParseExceptions()
+ {
+ return maxParseExceptions;
+ }
+
+ public int getMaxSavedParseExceptions()
+ {
+ return maxSavedParseExceptions;
+ }
+
+ /**
+ * Return the max number of rows per segment. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Nullable
+ @Override
+ @Deprecated
+ public Integer getMaxRowsPerSegment()
+ {
+ return partitionsSpec == null ? null : partitionsSpec.getMaxRowsPerSegment();
+ }
+
+ /**
+ * Return the max number of total rows in appenderator. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Override
+ @Nullable
+ @Deprecated
+ public Long getMaxTotalRows()
+ {
+ return partitionsSpec instanceof DynamicPartitionsSpec
+ ? ((DynamicPartitionsSpec) partitionsSpec).getMaxTotalRows()
+ : null;
+ }
+
+ @Deprecated
+ @Nullable
+ public Integer getNumShards()
Review comment:
Why do you want to add a deprecated method?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r655804581
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
Review comment:
The key thing is that `persistAllAndClear` needs to be called and *complete* before push. Basically nothing should be concurrent in `BatchAppenderator`. We should remove all this concurrent looking code because it is confusing but as of now that will be done in future work.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r655795808
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ //objectMapper.writeValue(descriptorFile, segment);
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ //sinks.put(identifier, currSink);
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
+ log.makeAlert(e, "Problem loading sink[%s] from disk.", schema.getDataSource())
+ .addData("identifier path", identifierPath)
+ .emit();
+ }
+ return null;
+ }
+
+ private ListenableFuture<?> removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed(sink));
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrants(hydrant));
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+ // Wait for any outstanding pushes to finish, then abandon the segment inside the persist thread.
+ return Futures.transform(
+ pushBarrier(),
+ new Function<Object, Void>()
+ {
+ @Nullable
+ @Override
+ public Void apply(@Nullable Object input)
+ {
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ return null;
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ for (FireHydrant hydrant : sink) {
+ if (cache != null) {
+ cache.close(SinkQuerySegmentWalker.makeHydrantCacheIdentifier(hydrant));
Review comment:
not needed, removed along with cache data member
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r666627334
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
+ {
+ if (partitionsSpec != null) {
+ return partitionsSpec;
+ }
+ return forceGuaranteedRollup
+ ? new HashedPartitionsSpec(null, null, null)
+ : new DynamicPartitionsSpec(null, null);
+ }
+
+ @Override
+ public IndexSpec getIndexSpec()
+ {
+ return indexSpec;
+ }
+
+ @Override
+ public IndexSpec getIndexSpecForIntermediatePersists()
+ {
+ return indexSpecForIntermediatePersists;
+ }
+
+ @Override
+ public int getMaxPendingPersists()
+ {
+ return maxPendingPersists;
+ }
+
+ public boolean isForceGuaranteedRollup()
Review comment:
Removed
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r664917883
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+ /* Reference to directory that holds the persisted data */
+ File persistedFileDir;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ public void setPersistedFileDir(File persistedFileDir)
+ {
+ this.persistedFileDir = persistedFileDir;
+ }
+
+ public File getPersistedFileDir()
+ {
+ return persistedFileDir;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ return null;
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrant();
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndRemoveSinks();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, false);
+ }
+
+ @Override
+ /**
+ * Returns all active segments regardless whether they are in memory or persisted
+ */
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinksMetadata.keySet());
+ }
+
+ @VisibleForTesting
+ public List<SegmentIdWithShardSpec> getInMemorySegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed());
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear()
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData)
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ // Drop everything.
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), removeOnDiskData);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ removeSink(identifier, sink, true);
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ if (committer != null) {
+ throw new ISE("committer must be null for BatchAppenderator");
+ }
+ persistAllAndRemoveSinks();
+ return Futures.immediateFuture(null);
+ }
+
+ /**
+ * Persist all sinks & their hydrants, keep their metadata, and then remove them completely from
+ * memory (to be resurrected right before merge & push)
+ */
+ private void persistAllAndRemoveSinks()
+ {
+
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ int totalHydrantsCount = 0;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ // Since everytime we persist we also get rid of the in-memory references to sinks & hydrants
+ // the invariant of exactly one, always swappable, sink with exactly one unpersisted hydrant must hold
+ int totalHydrantsForSink = hydrants.size();
+ if (totalHydrantsForSink != 1) {
+ throw new ISE("There should be only onw hydrant for identifier[%s] but there are[%s]",
+ identifier, totalHydrantsForSink
+ );
+ }
+ totalHydrantsCount += 1;
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ if (!sink.swappable()) {
+ throw new ISE("Sink is not swappable![%s]", identifier);
+ }
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+
+ }
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .filter(itp -> itp.rhs != null)
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], persisted sinks: [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ numPersistedRows,
+ totalSinks,
+ totalHydrantsCount
+ );
+
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ // remove all sinks after persisting:
+ clear(false);
+
+ log.info("Persisted rows[%,d] and bytes[%,d] and removed all sinks & hydrants from memory",
+ numPersistedRows, bytesPersisted);
+
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ if (useUniquePath) {
+ throw new ISE("Batch ingestion does not require uniquePath");
+ }
+
+
+ // Any sinks not persisted so far need to be persisted before push:
+ persistAllAndRemoveSinks();
+
+ log.info("Preparing to push...");
+
+ // get the dirs for the identfiers:
+ List<File> identifiersDirs = new ArrayList<>();
+ for (SegmentIdWithShardSpec identifier : identifiers) {
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ throw new ISE("No sink has been processed for identifier[%s]", identifier);
+ }
+ File persistedDir = sm.getPersistedFileDir();
+ if (persistedDir == null) {
+ throw new ISE("Sink for identifier[%s] not found in local file system", identifier);
+ }
+ identifiersDirs.add(persistedDir);
+ }
+
+ // push all sinks for identifiers:
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ for (File identifier : identifiersDirs) {
+
+ // retrieve sink from disk:
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks;
+ try {
+ identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ }
+ catch (IOException e) {
+ throw new ISE(e, "Failed to retrieve sinks for identifier[%s]", identifier);
+ }
+
+ // push it:
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ false
+ );
+
+ // record it:
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+
+ }
+ log.info("Push complete...");
+
+ return Futures.immediateFuture(new SegmentsAndCommitMetadata(dataSegments, null));
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
Review comment:
done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r664967315
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderator.java
##########
@@ -166,7 +166,16 @@
private volatile Throwable persistError;
+
+ /**
+ * Flag to tell internals whether appenderator is working on behalf of a real time task.
+ * This is to manage certain aspects as needed. For example, for batch, non-real time tasks,
+ * physical segments (i.e. hydrants) do not need to memory map their persisted
+ * files. In this case, the code will avoid memory mapping them thus ameliorating the occurance
+ * of OOMs.
+ */
private final boolean isRealTime;
Review comment:
It is used for the fall back flag.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658476554
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderator.java
##########
@@ -221,7 +221,10 @@ AppenderatorAddResult add(
* files. In this case, the code will avoid memory mapping them thus ameliorating the occurance
* of OOMs.
*/
- boolean isRealTime();
+ default boolean isRealTime()
+ {
+ return false;
Review comment:
Removed from interface
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658477956
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java
##########
@@ -172,7 +172,7 @@ SegmentWithState getAppendingSegment()
/**
* Allocated segments for a sequence
*/
- static class SegmentsForSequence
+ public static class SegmentsForSequence
Review comment:
They are needed in BatchAppenderatorDriverTest which is in a different module
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] jihoonson commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
jihoonson commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r664961372
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,859 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.column.ColumnConfig;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean batchFallback
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new IndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null
+ ).withBasePersistDirectory(basePersistDirectory != null ? basePersistDirectory : createNewBasePersistDirectory());
+
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ new ColumnConfig()
+ {
+ @Override
+ public int columnCacheSizeBytes()
+ {
+ return 0;
+ }
+ }
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ batchFallback
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing as is for testing since it is not accessible from server module,
+ // we could simplify since not all its functionality is being used
+ // but leaving as is, it could be useful later
+ private static class IndexTuningConfig implements AppenderatorConfig
Review comment:
Sorry I missed this change in my last review. Please clean up all the codes unused here in this class because there is no reason to keep them. It should really be a simple POJO. We can add some codes back if we really need later.
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,859 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.column.ColumnConfig;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean batchFallback
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new IndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null
+ ).withBasePersistDirectory(basePersistDirectory != null ? basePersistDirectory : createNewBasePersistDirectory());
+
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ new ColumnConfig()
+ {
+ @Override
+ public int columnCacheSizeBytes()
+ {
+ return 0;
+ }
+ }
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ batchFallback
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing as is for testing since it is not accessible from server module,
+ // we could simplify since not all its functionality is being used
+ // but leaving as is, it could be useful later
+ private static class IndexTuningConfig implements AppenderatorConfig
Review comment:
Sorry I missed this change in my last review. Please clean up all the codes unused here in this class because there is no reason to keep them. It should really be a simple POJO. We can add some codes back if we really need them later.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] jihoonson commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
jihoonson commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658288889
##########
File path: indexing-service/src/test/java/org/apache/druid/indexing/appenderator/BatchAppenderatorDriverTest.java
##########
@@ -199,4 +209,40 @@ static TransactionalSegmentPublisher makeOkPublisher()
{
return (segmentsToBeOverwritten, segmentsToBeDropped, segmentsToPublish, commitMetadata) -> SegmentPublishResult.ok(ImmutableSet.of());
}
+
+ static class TestSegmentAllocator implements SegmentAllocator
+ {
+ private final String dataSource;
+ private final Granularity granularity;
+ private final Map<Long, AtomicInteger> counters = new HashMap<>();
+
+ public TestSegmentAllocator(String dataSource, Granularity granularity)
+ {
+ this.dataSource = dataSource;
+ this.granularity = granularity;
+ }
+
+ @Override
+ public SegmentIdWithShardSpec allocate(
+ final InputRow row,
+ final String sequenceName,
+ final String previousSegmentId,
+ final boolean skipSegmentLineageCheck
+ )
+ {
+ synchronized (counters) {
Review comment:
`SegmentAllocator` is not thread-safe. The caller must ensure that one thread calls this method at a time.
##########
File path: server/pom.xml
##########
@@ -470,6 +470,7 @@
<excludes>
<!-- There are UTs for this class but it is very difficult to get required branch coverage -->
<exclude>org/apache/druid/metadata/BasicDataSourceExt.class</exclude>
+ <exclude>org/apache/druid/segment/realtime/appenderator/BatchAppenderator.class</exclude>
Review comment:
Why do we want to exclude this class from the coverage bot check?
##########
File path: indexing-service/src/test/java/org/apache/druid/indexing/appenderator/TestUsedSegmentChecker.java
##########
@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.indexing.appenderator;
+
+import com.google.common.collect.Ordering;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
+import org.apache.druid.segment.realtime.appenderator.UsedSegmentChecker;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.TimelineObjectHolder;
+import org.apache.druid.timeline.VersionedIntervalTimeline;
+import org.apache.druid.timeline.partition.PartitionChunk;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class TestUsedSegmentChecker implements UsedSegmentChecker
Review comment:
This class is identical to `org.apache.druid.segment.realtime.appenderator.TestUsedSegmentChecker`. Please use the existing one. You may need some refactoring on `TestUsedSegmentChecker` to support both realtime and batch appenderatorTesters. For example, its constructor can accept a `pushedSegmentsSupplier` of `Supplier<List<DataSegment>>`.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderator.java
##########
@@ -235,7 +238,7 @@ AppenderatorAddResult add(
private final int numRowsInSegment;
private final boolean isPersistRequired;
- AppenderatorAddResult(
+ public AppenderatorAddResult(
Review comment:
Why did you change the access modifier? This should not be called outside the package.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
Review comment:
This parameter is not in use.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
Review comment:
`persistError` is not needed but you can throw the exception immediately because the persist is now synchronous.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
Review comment:
The `isPersistRequired` variable is always false and thus not needed.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
+ log.makeAlert(e, "Problem loading sink[%s] from disk.", schema.getDataSource())
+ .addData("identifier path", identifierPath)
+ .emit();
+ }
+ return null;
+ }
+
+ private ListenableFuture<?> removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed(sink));
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrants(hydrant));
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+ // Wait for any outstanding pushes to finish, then abandon the segment inside the persist thread.
+ return Futures.transform(
+ pushBarrier(),
+ new Function<Object, Void>()
+ {
+ @Nullable
+ @Override
+ public Void apply(@Nullable Object input)
+ {
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ return null;
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ if (removeOnDiskData) {
+ removeDirectory(computePersistDir(identifier));
+ }
+
+ log.info("Removed sink for segment[%s].", identifier);
+
+ return null;
+ }
+ },
+ // use persistExecutor to make sure that all the pending persists completes before
+ // starting to abandon segments
+ persistExecutor
+ );
+ }
+
+ private File computeLockFile()
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), ".lock");
+ }
+
+ private File computePersistDir(SegmentIdWithShardSpec identifier)
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
+ }
+
+ private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
+ }
+
+ private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), "descriptor.json");
+ }
+
+ private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
+ {
+ final File persistDir = computePersistDir(identifier);
+ org.apache.commons.io.FileUtils.forceMkdir(persistDir);
+
+ objectMapper.writeValue(computeIdentifierFile(identifier), identifier);
+
+ return persistDir;
+ }
+
+ /**
+ * Persists the given hydrant and returns the number of rows persisted. Must only be called in the single-threaded
+ * persistExecutor.
+ *
+ * @param indexToPersist hydrant to persist
+ * @param identifier the segment this hydrant is going to be part of
+ * @return the number of rows persisted
+ */
+ private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
+ {
+ synchronized (indexToPersist) {
+ if (indexToPersist.hasSwapped()) {
+ log.info(
+ "Segment[%s] hydrant[%s] already swapped. Ignoring request to persist.",
+ identifier,
+ indexToPersist
+ );
+ return 0;
+ }
+
+ log.debug("Segment[%s], persisting Hydrant[%s]", identifier, indexToPersist);
+
+ try {
+ final long startTime = System.nanoTime();
+ int numRows = indexToPersist.getIndex().size();
+
+ // since the sink may have been persisted before it may have lost its
+ // hydrant count, we remember that value in the sinks metadata so we have
+ // to pull it from there....
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ final File persistDir = createPersistDirIfNeeded(identifier);
+ indexMerger.persist(
+ indexToPersist.getIndex(),
+ identifier.getInterval(),
+ new File(persistDir, String.valueOf(sm.getNumHydrants())),
+ tuningConfig.getIndexSpecForIntermediatePersists(),
+ tuningConfig.getSegmentWriteOutMediumFactory()
+ );
+
+ log.info(
+ "Persisted in-memory data for segment[%s] spill[%s] to disk in [%,d] ms (%,d rows).",
+ indexToPersist.getSegmentId(),
+ indexToPersist.getCount(),
+ (System.nanoTime() - startTime) / 1000000,
+ numRows
+ );
+
+ indexToPersist.swapSegment(null);
+ // remember hydrant count:
+ sinksMetadata.get(identifier).addHydrants(1);
+
+ return numRows;
+ }
+ catch (IOException e) {
+ log.makeAlert("Incremental persist failed")
+ .addData("segment", identifier.toString())
+ .addData("dataSource", schema.getDataSource())
+ .addData("count", indexToPersist.getCount())
+ .emit();
+
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void removeDirectory(final File target)
+ {
+ if (target.exists()) {
+ try {
+ FileUtils.deleteDirectory(target);
+ log.info("Removed directory [%s]", target);
+ }
+ catch (Exception e) {
+ log.makeAlert(e, "Failed to remove directory[%s]", schema.getDataSource())
+ .addData("file", target)
+ .emit();
+ }
+ }
+ }
+
+ private int calculateMemoryUsedByHydrants(FireHydrant hydrant)
Review comment:
The parameter is not in use.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
Review comment:
We don't seem to need `persistExecutor` because the only caller of this method is `persistAllAndClear()` which does wait for the future to complete immediately. If this is for not changing the `Appenderator` interface, you can execute this code sequentially but wrap the return value with `ImmediateFuture`.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
Review comment:
Also, in all the callers of this method, please handle the case where this returns null.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
Review comment:
Every exception should be propagated properly. Please rethrow it. Then this method doesn't have to return null.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java
##########
@@ -260,8 +260,7 @@ SegmentsOfInterval get(long timestamp)
);
}
- @VisibleForTesting
Review comment:
This is still used in only tests.
##########
File path: indexing-service/src/test/java/org/apache/druid/indexing/appenderator/BatchAppenderatorTester.java
##########
@@ -163,7 +177,7 @@ public BatchAppenderatorTester(
null,
null,
null
- ).withBasePersistDirectory(createNewBasePersistDirectory());
+ ).withBasePersistDirectory(basePersistDirectory != null ? basePersistDirectory : createNewBasePersistDirectory());
Review comment:
Please annotate the parameter `basePersistDirectory` with `Nullable`.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderator.java
##########
@@ -221,7 +221,10 @@ AppenderatorAddResult add(
* files. In this case, the code will avoid memory mapping them thus ameliorating the occurance
* of OOMs.
*/
- boolean isRealTime();
+ default boolean isRealTime()
+ {
+ return false;
Review comment:
This method is called only in `StreamAppenderator`. Do we need to expose this to outside of it? It seems that we can remove it from the `Appenderator` interface.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderators.java
##########
@@ -108,7 +108,28 @@ public static Appenderator createOffline(
boolean batchMemoryMappedIndex
)
{
- return new AppenderatorImpl(
+ if (batchMemoryMappedIndex) {
+ // fallback to code know to be working, this is just a fallback option in case new
+ // batch appenderator has some early bugs but we will remove this fallback as soon as
+ // we determine that batch appenderator code is stable
Review comment:
How can we determine that the new code is stable? Is there anything you are imagining what kind of testings we must do?
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java
##########
@@ -172,7 +172,7 @@ SegmentWithState getAppendingSegment()
/**
* Allocated segments for a sequence
*/
- static class SegmentsForSequence
+ public static class SegmentsForSequence
Review comment:
Why did you change these access modifiers? They are not supposed to be used outside the package.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderators.java
##########
@@ -108,7 +108,28 @@ public static Appenderator createOffline(
boolean batchMemoryMappedIndex
)
{
- return new AppenderatorImpl(
+ if (batchMemoryMappedIndex) {
+ // fallback to code know to be working, this is just a fallback option in case new
Review comment:
```suggestion
// fallback to code known to be working, this is just a fallback option in case new
```
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
Review comment:
```suggestion
sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
```
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
Review comment:
Please remove unused variable.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
Review comment:
There must be always 1 hydrant, isn't it? If so, I suggest adding a sanity check for one hydrant being in the sink instead.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
Review comment:
This transform seems doing nothing. Can we remove it?
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
Review comment:
Does `toPersist.get()` ever return a non-null metadata? If not, I suggest adding a sanity check for the null being returned instead here. Also, this method `persistAllAndClear()` doesn't need a return value because it always returns null.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
+ log.makeAlert(e, "Problem loading sink[%s] from disk.", schema.getDataSource())
+ .addData("identifier path", identifierPath)
+ .emit();
+ }
+ return null;
+ }
+
+ private ListenableFuture<?> removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed(sink));
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrants(hydrant));
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+ // Wait for any outstanding pushes to finish, then abandon the segment inside the persist thread.
+ return Futures.transform(
+ pushBarrier(),
+ new Function<Object, Void>()
+ {
+ @Nullable
+ @Override
+ public Void apply(@Nullable Object input)
+ {
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ return null;
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ if (removeOnDiskData) {
+ removeDirectory(computePersistDir(identifier));
+ }
+
+ log.info("Removed sink for segment[%s].", identifier);
+
+ return null;
+ }
+ },
+ // use persistExecutor to make sure that all the pending persists completes before
+ // starting to abandon segments
+ persistExecutor
+ );
+ }
+
+ private File computeLockFile()
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), ".lock");
+ }
+
+ private File computePersistDir(SegmentIdWithShardSpec identifier)
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
+ }
+
+ private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
+ }
+
+ private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), "descriptor.json");
+ }
+
+ private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
+ {
+ final File persistDir = computePersistDir(identifier);
+ org.apache.commons.io.FileUtils.forceMkdir(persistDir);
+
+ objectMapper.writeValue(computeIdentifierFile(identifier), identifier);
+
+ return persistDir;
+ }
+
+ /**
+ * Persists the given hydrant and returns the number of rows persisted. Must only be called in the single-threaded
+ * persistExecutor.
+ *
+ * @param indexToPersist hydrant to persist
+ * @param identifier the segment this hydrant is going to be part of
+ * @return the number of rows persisted
+ */
+ private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
+ {
+ synchronized (indexToPersist) {
+ if (indexToPersist.hasSwapped()) {
+ log.info(
+ "Segment[%s] hydrant[%s] already swapped. Ignoring request to persist.",
+ identifier,
+ indexToPersist
+ );
+ return 0;
+ }
+
+ log.debug("Segment[%s], persisting Hydrant[%s]", identifier, indexToPersist);
+
+ try {
+ final long startTime = System.nanoTime();
+ int numRows = indexToPersist.getIndex().size();
+
+ // since the sink may have been persisted before it may have lost its
+ // hydrant count, we remember that value in the sinks metadata so we have
+ // to pull it from there....
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ final File persistDir = createPersistDirIfNeeded(identifier);
+ indexMerger.persist(
+ indexToPersist.getIndex(),
+ identifier.getInterval(),
+ new File(persistDir, String.valueOf(sm.getNumHydrants())),
+ tuningConfig.getIndexSpecForIntermediatePersists(),
+ tuningConfig.getSegmentWriteOutMediumFactory()
+ );
+
+ log.info(
+ "Persisted in-memory data for segment[%s] spill[%s] to disk in [%,d] ms (%,d rows).",
+ indexToPersist.getSegmentId(),
+ indexToPersist.getCount(),
+ (System.nanoTime() - startTime) / 1000000,
+ numRows
+ );
+
+ indexToPersist.swapSegment(null);
+ // remember hydrant count:
+ sinksMetadata.get(identifier).addHydrants(1);
+
+ return numRows;
+ }
+ catch (IOException e) {
+ log.makeAlert("Incremental persist failed")
+ .addData("segment", identifier.toString())
+ .addData("dataSource", schema.getDataSource())
+ .addData("count", indexToPersist.getCount())
+ .emit();
+
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void removeDirectory(final File target)
+ {
+ if (target.exists()) {
+ try {
+ FileUtils.deleteDirectory(target);
+ log.info("Removed directory [%s]", target);
+ }
+ catch (Exception e) {
+ log.makeAlert(e, "Failed to remove directory[%s]", schema.getDataSource())
+ .addData("file", target)
+ .emit();
+ }
+ }
+ }
+
+ private int calculateMemoryUsedByHydrants(FireHydrant hydrant)
+ {
+ if (skipBytesInMemoryOverheadCheck) {
+ return 0;
+ }
+ // These calculations are approximated from actual heap dumps.
+ // Memory footprint includes count integer in FireHydrant, shorts in ReferenceCountingSegment,
+ // Objects in SimpleQueryableIndex (such as SmooshedFileMapper, each ColumnHolder in column map, etc.)
+ int total;
+ total = Integer.BYTES + (4 * Short.BYTES) + ROUGH_OVERHEAD_PER_HYDRANT;
+ return total;
+ }
+
+ private int calculateSinkMemoryInUsed(Sink sink)
Review comment:
The parameter is not in use.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
Review comment:
Similarly, you can use `Futures.immediateFuture` instead of executing the below code in background. This should make no impact because the only caller of this method is `BatchAppenderatorDriver` which always waits for the returned future to complete.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
+ log.makeAlert(e, "Problem loading sink[%s] from disk.", schema.getDataSource())
+ .addData("identifier path", identifierPath)
+ .emit();
+ }
+ return null;
+ }
+
+ private ListenableFuture<?> removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed(sink));
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrants(hydrant));
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+ // Wait for any outstanding pushes to finish, then abandon the segment inside the persist thread.
+ return Futures.transform(
+ pushBarrier(),
+ new Function<Object, Void>()
+ {
+ @Nullable
+ @Override
+ public Void apply(@Nullable Object input)
+ {
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ return null;
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ if (removeOnDiskData) {
+ removeDirectory(computePersistDir(identifier));
+ }
+
+ log.info("Removed sink for segment[%s].", identifier);
+
+ return null;
+ }
+ },
+ // use persistExecutor to make sure that all the pending persists completes before
+ // starting to abandon segments
+ persistExecutor
+ );
+ }
+
+ private File computeLockFile()
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), ".lock");
+ }
+
+ private File computePersistDir(SegmentIdWithShardSpec identifier)
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
+ }
+
+ private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
+ }
+
+ private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), "descriptor.json");
+ }
+
+ private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
+ {
+ final File persistDir = computePersistDir(identifier);
+ org.apache.commons.io.FileUtils.forceMkdir(persistDir);
+
+ objectMapper.writeValue(computeIdentifierFile(identifier), identifier);
+
+ return persistDir;
+ }
+
+ /**
+ * Persists the given hydrant and returns the number of rows persisted. Must only be called in the single-threaded
+ * persistExecutor.
+ *
+ * @param indexToPersist hydrant to persist
+ * @param identifier the segment this hydrant is going to be part of
+ * @return the number of rows persisted
+ */
+ private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
+ {
+ synchronized (indexToPersist) {
+ if (indexToPersist.hasSwapped()) {
+ log.info(
+ "Segment[%s] hydrant[%s] already swapped. Ignoring request to persist.",
+ identifier,
+ indexToPersist
+ );
+ return 0;
+ }
+
+ log.debug("Segment[%s], persisting Hydrant[%s]", identifier, indexToPersist);
+
+ try {
+ final long startTime = System.nanoTime();
+ int numRows = indexToPersist.getIndex().size();
+
+ // since the sink may have been persisted before it may have lost its
+ // hydrant count, we remember that value in the sinks metadata so we have
+ // to pull it from there....
+ SinkMetadata sm = sinksMetadata.get(identifier);
Review comment:
Please add a sanity check for `sm` to not be null.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
Review comment:
This method can be private.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
Review comment:
Please add `Nullable` for the return value.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
Review comment:
You can use `sm.getNumHydrants()` instead of looking up the map again here and in the line below.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
Review comment:
Please use `IDENTIFIER_FILE_NAME` instead.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] jihoonson commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
jihoonson commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r664768612
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+ /* Reference to directory that holds the persisted data */
+ File persistedFileDir;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ public void setPersistedFileDir(File persistedFileDir)
+ {
+ this.persistedFileDir = persistedFileDir;
+ }
+
+ public File getPersistedFileDir()
+ {
+ return persistedFileDir;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ return null;
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrant();
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndRemoveSinks();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, false);
+ }
+
+ @Override
+ /**
+ * Returns all active segments regardless whether they are in memory or persisted
+ */
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinksMetadata.keySet());
+ }
+
+ @VisibleForTesting
+ public List<SegmentIdWithShardSpec> getInMemorySegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed());
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear()
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData)
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ // Drop everything.
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), removeOnDiskData);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ removeSink(identifier, sink, true);
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ if (committer != null) {
+ throw new ISE("committer must be null for BatchAppenderator");
+ }
+ persistAllAndRemoveSinks();
+ return Futures.immediateFuture(null);
+ }
+
+ /**
+ * Persist all sinks & their hydrants, keep their metadata, and then remove them completely from
+ * memory (to be resurrected right before merge & push)
+ */
+ private void persistAllAndRemoveSinks()
+ {
+
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ int totalHydrantsCount = 0;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ // Since everytime we persist we also get rid of the in-memory references to sinks & hydrants
+ // the invariant of exactly one, always swappable, sink with exactly one unpersisted hydrant must hold
+ int totalHydrantsForSink = hydrants.size();
+ if (totalHydrantsForSink != 1) {
+ throw new ISE("There should be only onw hydrant for identifier[%s] but there are[%s]",
+ identifier, totalHydrantsForSink
+ );
+ }
+ totalHydrantsCount += 1;
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ if (!sink.swappable()) {
+ throw new ISE("Sink is not swappable![%s]", identifier);
+ }
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+
+ }
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .filter(itp -> itp.rhs != null)
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], persisted sinks: [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ numPersistedRows,
+ totalSinks,
+ totalHydrantsCount
+ );
+
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ // remove all sinks after persisting:
+ clear(false);
+
+ log.info("Persisted rows[%,d] and bytes[%,d] and removed all sinks & hydrants from memory",
+ numPersistedRows, bytesPersisted);
+
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ if (useUniquePath) {
+ throw new ISE("Batch ingestion does not require uniquePath");
+ }
+
+
+ // Any sinks not persisted so far need to be persisted before push:
+ persistAllAndRemoveSinks();
+
+ log.info("Preparing to push...");
+
+ // get the dirs for the identfiers:
+ List<File> identifiersDirs = new ArrayList<>();
+ for (SegmentIdWithShardSpec identifier : identifiers) {
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ throw new ISE("No sink has been processed for identifier[%s]", identifier);
+ }
+ File persistedDir = sm.getPersistedFileDir();
+ if (persistedDir == null) {
+ throw new ISE("Sink for identifier[%s] not found in local file system", identifier);
+ }
+ identifiersDirs.add(persistedDir);
+ }
+
+ // push all sinks for identifiers:
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ for (File identifier : identifiersDirs) {
+
+ // retrieve sink from disk:
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks;
+ try {
+ identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ }
+ catch (IOException e) {
+ throw new ISE(e, "Failed to retrieve sinks for identifier[%s]", identifier);
+ }
+
+ // push it:
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ false
+ );
+
+ // record it:
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+
+ }
+ log.info("Push complete...");
+
+ return Futures.immediateFuture(new SegmentsAndCommitMetadata(dataSegments, null));
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
Review comment:
No need for synchronization.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+ /* Reference to directory that holds the persisted data */
+ File persistedFileDir;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ public void setPersistedFileDir(File persistedFileDir)
+ {
+ this.persistedFileDir = persistedFileDir;
+ }
+
+ public File getPersistedFileDir()
+ {
+ return persistedFileDir;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ return null;
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrant();
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndRemoveSinks();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, false);
+ }
+
+ @Override
+ /**
+ * Returns all active segments regardless whether they are in memory or persisted
+ */
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinksMetadata.keySet());
+ }
+
+ @VisibleForTesting
+ public List<SegmentIdWithShardSpec> getInMemorySegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed());
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear()
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData)
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ // Drop everything.
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), removeOnDiskData);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ removeSink(identifier, sink, true);
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ if (committer != null) {
+ throw new ISE("committer must be null for BatchAppenderator");
+ }
+ persistAllAndRemoveSinks();
+ return Futures.immediateFuture(null);
+ }
+
+ /**
+ * Persist all sinks & their hydrants, keep their metadata, and then remove them completely from
+ * memory (to be resurrected right before merge & push)
+ */
+ private void persistAllAndRemoveSinks()
+ {
+
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ int totalHydrantsCount = 0;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ // Since everytime we persist we also get rid of the in-memory references to sinks & hydrants
+ // the invariant of exactly one, always swappable, sink with exactly one unpersisted hydrant must hold
+ int totalHydrantsForSink = hydrants.size();
+ if (totalHydrantsForSink != 1) {
+ throw new ISE("There should be only onw hydrant for identifier[%s] but there are[%s]",
+ identifier, totalHydrantsForSink
+ );
+ }
+ totalHydrantsCount += 1;
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ if (!sink.swappable()) {
+ throw new ISE("Sink is not swappable![%s]", identifier);
+ }
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+
+ }
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .filter(itp -> itp.rhs != null)
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], persisted sinks: [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ numPersistedRows,
+ totalSinks,
+ totalHydrantsCount
+ );
+
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ // remove all sinks after persisting:
+ clear(false);
+
+ log.info("Persisted rows[%,d] and bytes[%,d] and removed all sinks & hydrants from memory",
+ numPersistedRows, bytesPersisted);
+
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ if (useUniquePath) {
+ throw new ISE("Batch ingestion does not require uniquePath");
+ }
+
+
+ // Any sinks not persisted so far need to be persisted before push:
+ persistAllAndRemoveSinks();
+
+ log.info("Preparing to push...");
+
+ // get the dirs for the identfiers:
+ List<File> identifiersDirs = new ArrayList<>();
+ for (SegmentIdWithShardSpec identifier : identifiers) {
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ throw new ISE("No sink has been processed for identifier[%s]", identifier);
+ }
+ File persistedDir = sm.getPersistedFileDir();
+ if (persistedDir == null) {
+ throw new ISE("Sink for identifier[%s] not found in local file system", identifier);
+ }
+ identifiersDirs.add(persistedDir);
+ }
+
+ // push all sinks for identifiers:
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ for (File identifier : identifiersDirs) {
+
+ // retrieve sink from disk:
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks;
+ try {
+ identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ }
+ catch (IOException e) {
+ throw new ISE(e, "Failed to retrieve sinks for identifier[%s]", identifier);
+ }
+
+ // push it:
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ false
+ );
+
+ // record it:
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+
+ }
+ log.info("Push complete...");
+
+ return Futures.immediateFuture(new SegmentsAndCommitMetadata(dataSegments, null));
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
Review comment:
`useUniquePath` is always false so you can remove it.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+ /* Reference to directory that holds the persisted data */
+ File persistedFileDir;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ public void setPersistedFileDir(File persistedFileDir)
+ {
+ this.persistedFileDir = persistedFileDir;
+ }
+
+ public File getPersistedFileDir()
+ {
+ return persistedFileDir;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ return null;
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrant();
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndRemoveSinks();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, false);
+ }
+
+ @Override
+ /**
+ * Returns all active segments regardless whether they are in memory or persisted
+ */
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinksMetadata.keySet());
+ }
+
+ @VisibleForTesting
+ public List<SegmentIdWithShardSpec> getInMemorySegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed());
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear()
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData)
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ // Drop everything.
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), removeOnDiskData);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ removeSink(identifier, sink, true);
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ if (committer != null) {
+ throw new ISE("committer must be null for BatchAppenderator");
+ }
+ persistAllAndRemoveSinks();
+ return Futures.immediateFuture(null);
+ }
+
+ /**
+ * Persist all sinks & their hydrants, keep their metadata, and then remove them completely from
+ * memory (to be resurrected right before merge & push)
+ */
+ private void persistAllAndRemoveSinks()
+ {
+
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ int totalHydrantsCount = 0;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ // Since everytime we persist we also get rid of the in-memory references to sinks & hydrants
+ // the invariant of exactly one, always swappable, sink with exactly one unpersisted hydrant must hold
+ int totalHydrantsForSink = hydrants.size();
+ if (totalHydrantsForSink != 1) {
+ throw new ISE("There should be only onw hydrant for identifier[%s] but there are[%s]",
Review comment:
```suggestion
throw new ISE("There should be only one hydrant for identifier[%s] but there are[%s]",
```
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+ /* Reference to directory that holds the persisted data */
+ File persistedFileDir;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ public void setPersistedFileDir(File persistedFileDir)
+ {
+ this.persistedFileDir = persistedFileDir;
+ }
+
+ public File getPersistedFileDir()
+ {
+ return persistedFileDir;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ return null;
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrant();
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndRemoveSinks();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, false);
+ }
+
+ @Override
+ /**
+ * Returns all active segments regardless whether they are in memory or persisted
+ */
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinksMetadata.keySet());
+ }
+
+ @VisibleForTesting
+ public List<SegmentIdWithShardSpec> getInMemorySegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed());
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear()
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData)
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ // Drop everything.
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), removeOnDiskData);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ removeSink(identifier, sink, true);
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ if (committer != null) {
+ throw new ISE("committer must be null for BatchAppenderator");
+ }
+ persistAllAndRemoveSinks();
+ return Futures.immediateFuture(null);
+ }
+
+ /**
+ * Persist all sinks & their hydrants, keep their metadata, and then remove them completely from
+ * memory (to be resurrected right before merge & push)
+ */
+ private void persistAllAndRemoveSinks()
+ {
+
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ int totalHydrantsCount = 0;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ // Since everytime we persist we also get rid of the in-memory references to sinks & hydrants
+ // the invariant of exactly one, always swappable, sink with exactly one unpersisted hydrant must hold
+ int totalHydrantsForSink = hydrants.size();
+ if (totalHydrantsForSink != 1) {
+ throw new ISE("There should be only onw hydrant for identifier[%s] but there are[%s]",
+ identifier, totalHydrantsForSink
+ );
+ }
+ totalHydrantsCount += 1;
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ if (!sink.swappable()) {
+ throw new ISE("Sink is not swappable![%s]", identifier);
+ }
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+
+ }
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .filter(itp -> itp.rhs != null)
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], persisted sinks: [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ numPersistedRows,
+ totalSinks,
+ totalHydrantsCount
+ );
+
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ // remove all sinks after persisting:
+ clear(false);
+
+ log.info("Persisted rows[%,d] and bytes[%,d] and removed all sinks & hydrants from memory",
+ numPersistedRows, bytesPersisted);
+
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ if (useUniquePath) {
+ throw new ISE("Batch ingestion does not require uniquePath");
+ }
+
+
+ // Any sinks not persisted so far need to be persisted before push:
+ persistAllAndRemoveSinks();
+
+ log.info("Preparing to push...");
+
+ // get the dirs for the identfiers:
+ List<File> identifiersDirs = new ArrayList<>();
+ for (SegmentIdWithShardSpec identifier : identifiers) {
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ throw new ISE("No sink has been processed for identifier[%s]", identifier);
+ }
+ File persistedDir = sm.getPersistedFileDir();
+ if (persistedDir == null) {
+ throw new ISE("Sink for identifier[%s] not found in local file system", identifier);
+ }
+ identifiersDirs.add(persistedDir);
+ }
+
+ // push all sinks for identifiers:
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ for (File identifier : identifiersDirs) {
+
+ // retrieve sink from disk:
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks;
+ try {
+ identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ }
+ catch (IOException e) {
+ throw new ISE(e, "Failed to retrieve sinks for identifier[%s]", identifier);
+ }
+
+ // push it:
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ false
+ );
+
+ // record it:
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+
+ }
+ log.info("Push complete...");
+
+ return Futures.immediateFuture(new SegmentsAndCommitMetadata(dataSegments, null));
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sm.getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sm.getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+ if (useUniquePath) {
+ throw new ISE("Merge and push for batch appenderator does not use unique path");
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // This appenderator is used only for the local indexing task so unique paths are not required
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), false);
+ }
+
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ if (persistedIdentifiers != null) {
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ Nothing to do since there are no executors
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @VisibleForTesting
+ @Nullable
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ private Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ throws IOException
+ {
+
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, IDENTIFIER_FILE_NAME),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+ if (sinkFiles == null) {
+ throw new ISE("Problem reading persisted sinks in path[%s]", identifierPath);
+ }
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ return new Pair<>(identifier, currSink);
+ }
+
+ private void removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed());
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrant());
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ if (removeOnDiskData) {
+ removeDirectory(computePersistDir(identifier));
+ }
+
+ log.info("Removed sink for segment[%s].", identifier);
+
+ }
+
+ private File computeLockFile()
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), ".lock");
+ }
+
+ private File computePersistDir(SegmentIdWithShardSpec identifier)
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
+ }
+
+ private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
+ }
+
+ private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), "descriptor.json");
+ }
+
+ private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
+ {
+ final File persistDir = computePersistDir(identifier);
+ org.apache.commons.io.FileUtils.forceMkdir(persistDir);
+
+ objectMapper.writeValue(computeIdentifierFile(identifier), identifier);
+
+ return persistDir;
+ }
+
+ /**
+ * Persists the given hydrant and returns the number of rows persisted.
+ *
+ * @param indexToPersist hydrant to persist
+ * @param identifier the segment this hydrant is going to be part of
+ * @return the number of rows persisted
+ */
+ private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
+ {
+ synchronized (indexToPersist) {
Review comment:
No need for synchronization.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r661903822
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ return null;
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrant();
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, false);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed());
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData)
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ // Drop everything.
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), removeOnDiskData);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ removeSink(identifier, sink, true);
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ private void persistAllAndClear()
+ {
+ // make sure sinks are cleared before push is called
+ try {
+ persistAll(null).get();
+ clear(false);
+ }
+ catch (Throwable t) {
+ throw new RE(t, "Error while persisting");
+ }
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .filter(itp -> itp.rhs != null)
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ persistAllAndClear();
+
+ log.info("Preparing to push...");
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ if (persistedIdentifiers == null) {
+ throw new ISE("Identifiers were persisted but could not be retrieved");
+ }
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks;
+ try {
+ identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ }
+ catch (IOException e) {
+ throw new ISE(e, "Failed to retrieve sinks for identifier", identifier);
+ }
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+ log.info("Push complete...");
+
+ return Futures.immediateFuture(new SegmentsAndCommitMetadata(dataSegments, null));
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sm.getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), false);
+ }
+
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ if (persistedIdentifiers != null) {
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ Nothing to do since there are no executors
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @VisibleForTesting
+ @Nullable
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ private Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ throws IOException
+ {
+
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, IDENTIFIER_FILE_NAME),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+ if (sinkFiles == null) {
+ throw new ISE("Problem reading persisted sinks in path", identifierPath);
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658483197
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
Review comment:
done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658504542
##########
File path: indexing-service/src/test/java/org/apache/druid/indexing/appenderator/TestUsedSegmentChecker.java
##########
@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.indexing.appenderator;
+
+import com.google.common.collect.Ordering;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
+import org.apache.druid.segment.realtime.appenderator.UsedSegmentChecker;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.TimelineObjectHolder;
+import org.apache.druid.timeline.VersionedIntervalTimeline;
+import org.apache.druid.timeline.partition.PartitionChunk;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class TestUsedSegmentChecker implements UsedSegmentChecker
Review comment:
done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r665805427
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,859 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.column.ColumnConfig;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean batchFallback
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new IndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null
+ ).withBasePersistDirectory(basePersistDirectory != null ? basePersistDirectory : createNewBasePersistDirectory());
+
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ new ColumnConfig()
+ {
+ @Override
+ public int columnCacheSizeBytes()
+ {
+ return 0;
+ }
+ }
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ batchFallback
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing as is for testing since it is not accessible from server module,
+ // we could simplify since not all its functionality is being used
+ // but leaving as is, it could be useful later
+ private static class IndexTuningConfig implements AppenderatorConfig
Review comment:
It is already simple as much as it can be. Most of the code is setting defaults (when nulls are passed to the constructor) that are necessary for appenderator to function. I would like to leave it as is.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658528708
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] clintropolis commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
clintropolis commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r664975278
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderator.java
##########
@@ -166,7 +166,16 @@
private volatile Throwable persistError;
+
+ /**
+ * Flag to tell internals whether appenderator is working on behalf of a real time task.
+ * This is to manage certain aspects as needed. For example, for batch, non-real time tasks,
+ * physical segments (i.e. hydrants) do not need to memory map their persisted
+ * files. In this case, the code will avoid memory mapping them thus ameliorating the occurance
+ * of OOMs.
+ */
private final boolean isRealTime;
Review comment:
It is not really though, when the fallback is set to true, `StreamAppenderator` is made with isRealtime hard coded to false, instead of controlled by a flag as was introduced in #11123. This means there is no way to revert the behavior of that PR since it isn't operator controllable anymore. Rather than introduce a 2nd flag, I strongly think we should consider removing the isRealtime from `StreamAppenderator` before 0.22 since the behavior was previously unreleased and now there is no way to not use it (I don't think there is enough time to have no setting at all and always use `BatchAppenderator`, so that flag will still need to exist to choose between them).
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] maytasm commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
maytasm commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r655025802
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
Review comment:
Should this be inside the Callable?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r665806195
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r666627433
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
Review comment:
removed
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r665807108
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,859 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.column.ColumnConfig;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
Review comment:
I decided to create different tester classes for stream & batch so as not to couple the, together. I will remove the json annotations.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658488066
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
Review comment:
done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] maytasm commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
maytasm commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r655025016
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ //objectMapper.writeValue(descriptorFile, segment);
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ //sinks.put(identifier, currSink);
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
+ log.makeAlert(e, "Problem loading sink[%s] from disk.", schema.getDataSource())
+ .addData("identifier path", identifierPath)
+ .emit();
+ }
+ return null;
+ }
+
+ private ListenableFuture<?> removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed(sink));
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrants(hydrant));
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+ // Wait for any outstanding pushes to finish, then abandon the segment inside the persist thread.
+ return Futures.transform(
+ pushBarrier(),
+ new Function<Object, Void>()
+ {
+ @Nullable
+ @Override
+ public Void apply(@Nullable Object input)
+ {
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ return null;
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ for (FireHydrant hydrant : sink) {
+ if (cache != null) {
+ cache.close(SinkQuerySegmentWalker.makeHydrantCacheIdentifier(hydrant));
+ }
+ hydrant.swapSegment(null);
+ }
+
+ if (removeOnDiskData) {
+ removeDirectory(computePersistDir(identifier));
+ }
+
+ log.info("Removed sink for segment[%s].", identifier);
+
+ return null;
+ }
+ },
+ // use persistExecutor to make sure that all the pending persists completes before
+ // starting to abandon segments
+ persistExecutor
+ );
+ }
+
+ private File computeLockFile()
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), ".lock");
+ }
+
+ private File computePersistDir(SegmentIdWithShardSpec identifier)
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
+ }
+
+ private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
+ }
+
+ private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), "descriptor.json");
+ }
+
+ private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
+ {
+ final File persistDir = computePersistDir(identifier);
+ org.apache.commons.io.FileUtils.forceMkdir(persistDir);
+
+ objectMapper.writeValue(computeIdentifierFile(identifier), identifier);
+
+ return persistDir;
+ }
+
+ /**
+ * Persists the given hydrant and returns the number of rows persisted. Must only be called in the single-threaded
+ * persistExecutor.
+ *
+ * @param indexToPersist hydrant to persist
+ * @param identifier the segment this hydrant is going to be part of
+ * @return the number of rows persisted
+ */
+ private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
+ {
+ synchronized (indexToPersist) {
+ if (indexToPersist.hasSwapped()) {
+ log.info(
+ "Segment[%s] hydrant[%s] already swapped. Ignoring request to persist.",
+ identifier,
+ indexToPersist
+ );
+ return 0;
+ }
+
+ log.debug("Segment[%s], persisting Hydrant[%s]", identifier, indexToPersist);
+
+ try {
+ final long startTime = System.nanoTime();
+ int numRows = indexToPersist.getIndex().size();
+
+ // since the sink may have been persisted before it may have lost its
+ // hydrant count, we remember that value in the sinks metadata so we have
+ // to pull it from there....
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ final File persistDir = createPersistDirIfNeeded(identifier);
+ indexMerger.persist(
+ indexToPersist.getIndex(),
+ identifier.getInterval(),
+ new File(persistDir, String.valueOf(sm.getNumHydrants())),
+ tuningConfig.getIndexSpecForIntermediatePersists(),
+ tuningConfig.getSegmentWriteOutMediumFactory()
+ );
+
+ log.info(
+ "Persisted in-memory data for segment[%s] spill[%s] to disk in [%,d] ms (%,d rows).",
+ indexToPersist.getSegmentId(),
+ indexToPersist.getCount(),
+ (System.nanoTime() - startTime) / 1000000,
+ numRows
+ );
+
+ indexToPersist.swapSegment(null);
+ // remember hydrant count:
+ sinksMetadata.get(identifier).addHydrants(1);
+
+ return numRows;
+ }
+ catch (IOException e) {
+ log.makeAlert("Incremental persist failed")
+ .addData("segment", identifier.toString())
+ .addData("dataSource", schema.getDataSource())
+ .addData("count", indexToPersist.getCount())
+ .emit();
+
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void removeDirectory(final File target)
+ {
+ if (target.exists()) {
+ try {
+ FileUtils.deleteDirectory(target);
+ log.info("Removed directory [%s]", target);
+ }
+ catch (Exception e) {
+ log.makeAlert(e, "Failed to remove directory[%s]", schema.getDataSource())
+ .addData("file", target)
+ .emit();
+ }
+ }
+ }
+
+ private int calculateMemoryUsedByHydrants(FireHydrant hydrant)
+ {
+ if (skipBytesInMemoryOverheadCheck) {
+ return 0;
+ }
+ // These calculations are approximated from actual heap dumps.
+ // Memory footprint includes count integer in FireHydrant, shorts in ReferenceCountingSegment,
+ // Objects in SimpleQueryableIndex (such as SmooshedFileMapper, each ColumnHolder in column map, etc.)
+ int total;
+ total = Integer.BYTES + (4 * Short.BYTES) + ROUGH_OVERHEAD_PER_HYDRANT;
Review comment:
Is this calculation still accurate?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] jihoonson commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
jihoonson commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r659100395
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderators.java
##########
@@ -108,7 +108,28 @@ public static Appenderator createOffline(
boolean batchMemoryMappedIndex
)
{
- return new AppenderatorImpl(
+ if (batchMemoryMappedIndex) {
Review comment:
I'm OK with it as long as we have only one flag.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658505056
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
+ log.makeAlert(e, "Problem loading sink[%s] from disk.", schema.getDataSource())
+ .addData("identifier path", identifierPath)
+ .emit();
+ }
+ return null;
+ }
+
+ private ListenableFuture<?> removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed(sink));
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrants(hydrant));
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+ // Wait for any outstanding pushes to finish, then abandon the segment inside the persist thread.
+ return Futures.transform(
+ pushBarrier(),
+ new Function<Object, Void>()
+ {
+ @Nullable
+ @Override
+ public Void apply(@Nullable Object input)
+ {
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ return null;
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ if (removeOnDiskData) {
+ removeDirectory(computePersistDir(identifier));
+ }
+
+ log.info("Removed sink for segment[%s].", identifier);
+
+ return null;
+ }
+ },
+ // use persistExecutor to make sure that all the pending persists completes before
+ // starting to abandon segments
+ persistExecutor
+ );
+ }
+
+ private File computeLockFile()
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), ".lock");
+ }
+
+ private File computePersistDir(SegmentIdWithShardSpec identifier)
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
+ }
+
+ private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
+ }
+
+ private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), "descriptor.json");
+ }
+
+ private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
+ {
+ final File persistDir = computePersistDir(identifier);
+ org.apache.commons.io.FileUtils.forceMkdir(persistDir);
+
+ objectMapper.writeValue(computeIdentifierFile(identifier), identifier);
+
+ return persistDir;
+ }
+
+ /**
+ * Persists the given hydrant and returns the number of rows persisted. Must only be called in the single-threaded
+ * persistExecutor.
+ *
+ * @param indexToPersist hydrant to persist
+ * @param identifier the segment this hydrant is going to be part of
+ * @return the number of rows persisted
+ */
+ private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
+ {
+ synchronized (indexToPersist) {
+ if (indexToPersist.hasSwapped()) {
+ log.info(
+ "Segment[%s] hydrant[%s] already swapped. Ignoring request to persist.",
+ identifier,
+ indexToPersist
+ );
+ return 0;
+ }
+
+ log.debug("Segment[%s], persisting Hydrant[%s]", identifier, indexToPersist);
+
+ try {
+ final long startTime = System.nanoTime();
+ int numRows = indexToPersist.getIndex().size();
+
+ // since the sink may have been persisted before it may have lost its
+ // hydrant count, we remember that value in the sinks metadata so we have
+ // to pull it from there....
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ final File persistDir = createPersistDirIfNeeded(identifier);
+ indexMerger.persist(
+ indexToPersist.getIndex(),
+ identifier.getInterval(),
+ new File(persistDir, String.valueOf(sm.getNumHydrants())),
+ tuningConfig.getIndexSpecForIntermediatePersists(),
+ tuningConfig.getSegmentWriteOutMediumFactory()
+ );
+
+ log.info(
+ "Persisted in-memory data for segment[%s] spill[%s] to disk in [%,d] ms (%,d rows).",
+ indexToPersist.getSegmentId(),
+ indexToPersist.getCount(),
+ (System.nanoTime() - startTime) / 1000000,
+ numRows
+ );
+
+ indexToPersist.swapSegment(null);
+ // remember hydrant count:
+ sinksMetadata.get(identifier).addHydrants(1);
+
+ return numRows;
+ }
+ catch (IOException e) {
+ log.makeAlert("Incremental persist failed")
+ .addData("segment", identifier.toString())
+ .addData("dataSource", schema.getDataSource())
+ .addData("count", indexToPersist.getCount())
+ .emit();
+
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void removeDirectory(final File target)
+ {
+ if (target.exists()) {
+ try {
+ FileUtils.deleteDirectory(target);
+ log.info("Removed directory [%s]", target);
+ }
+ catch (Exception e) {
+ log.makeAlert(e, "Failed to remove directory[%s]", schema.getDataSource())
+ .addData("file", target)
+ .emit();
+ }
+ }
+ }
+
+ private int calculateMemoryUsedByHydrants(FireHydrant hydrant)
+ {
+ if (skipBytesInMemoryOverheadCheck) {
+ return 0;
+ }
+ // These calculations are approximated from actual heap dumps.
+ // Memory footprint includes count integer in FireHydrant, shorts in ReferenceCountingSegment,
+ // Objects in SimpleQueryableIndex (such as SmooshedFileMapper, each ColumnHolder in column map, etc.)
+ int total;
+ total = Integer.BYTES + (4 * Short.BYTES) + ROUGH_OVERHEAD_PER_HYDRANT;
+ return total;
+ }
+
+ private int calculateSinkMemoryInUsed(Sink sink)
Review comment:
Removed
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658532268
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
Review comment:
Let's talk about this one
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658554806
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderators.java
##########
@@ -108,7 +108,28 @@ public static Appenderator createOffline(
boolean batchMemoryMappedIndex
)
{
- return new AppenderatorImpl(
+ if (batchMemoryMappedIndex) {
Review comment:
Updated the name of the flag as well as documentation (`batchFallBack`)
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon closed pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon closed pull request #11294:
URL: https://github.com/apache/druid/pull/11294
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] jihoonson commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
jihoonson commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658470583
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderators.java
##########
@@ -108,7 +108,28 @@ public static Appenderator createOffline(
boolean batchMemoryMappedIndex
)
{
- return new AppenderatorImpl(
+ if (batchMemoryMappedIndex) {
Review comment:
This changes the behavior of `batchMemoryMappedIndex` which is documented. Luckily, this flag was added in http://github.com/apache/druid/pull/11123, which is not included in any release yet. So we should either fix the document for this config or not change the behavior. So, thinking about the flag, do we really need it? Per your comment below, I guess you want to have these flags for providing a workaround to users just in case where some unknown bugs are found after release. If this is the case, I understand why you want, but it doesn't seem to me like a right direction. No bugs found in production environments for a certain period of time doesn't necessarily mean that some particular code area is completely free from bugs. Rather, it means no bugs have been found in that area yet. So, it's always possible that we find new bugs after we think this code area is stable and get rid of these flags. If you are worrying about potential bugs in this change, I think we should rathe
r add more tests to get more confidence. If you are not confident enough, we should plan out what kind of tests we need more and add them.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r661902343
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -764,7 +691,7 @@ private DataSegment mergeAndPush(
SinkMetadata sm = sinksMetadata.get(identifier);
if (sm == null) {
log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
- } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ } else if (numHydrants != sm.getNumHydrants()) {
throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r655795344
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ //objectMapper.writeValue(descriptorFile, segment);
Review comment:
Not required, removed.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ //objectMapper.writeValue(descriptorFile, segment);
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ //sinks.put(identifier, currSink);
Review comment:
done
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ //objectMapper.writeValue(descriptorFile, segment);
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ //sinks.put(identifier, currSink);
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
+ log.makeAlert(e, "Problem loading sink[%s] from disk.", schema.getDataSource())
+ .addData("identifier path", identifierPath)
+ .emit();
+ }
+ return null;
+ }
+
+ private ListenableFuture<?> removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed(sink));
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrants(hydrant));
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+ // Wait for any outstanding pushes to finish, then abandon the segment inside the persist thread.
+ return Futures.transform(
+ pushBarrier(),
+ new Function<Object, Void>()
+ {
+ @Nullable
+ @Override
+ public Void apply(@Nullable Object input)
+ {
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ return null;
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ for (FireHydrant hydrant : sink) {
+ if (cache != null) {
+ cache.close(SinkQuerySegmentWalker.makeHydrantCacheIdentifier(hydrant));
Review comment:
not needed, removed along with cache data member
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ //objectMapper.writeValue(descriptorFile, segment);
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ //sinks.put(identifier, currSink);
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
+ log.makeAlert(e, "Problem loading sink[%s] from disk.", schema.getDataSource())
+ .addData("identifier path", identifierPath)
+ .emit();
+ }
+ return null;
+ }
+
+ private ListenableFuture<?> removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed(sink));
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrants(hydrant));
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+ // Wait for any outstanding pushes to finish, then abandon the segment inside the persist thread.
+ return Futures.transform(
+ pushBarrier(),
+ new Function<Object, Void>()
+ {
+ @Nullable
+ @Override
+ public Void apply(@Nullable Object input)
+ {
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ return null;
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ for (FireHydrant hydrant : sink) {
+ if (cache != null) {
+ cache.close(SinkQuerySegmentWalker.makeHydrantCacheIdentifier(hydrant));
+ }
+ hydrant.swapSegment(null);
+ }
+
+ if (removeOnDiskData) {
+ removeDirectory(computePersistDir(identifier));
+ }
+
+ log.info("Removed sink for segment[%s].", identifier);
+
+ return null;
+ }
+ },
+ // use persistExecutor to make sure that all the pending persists completes before
+ // starting to abandon segments
+ persistExecutor
+ );
+ }
+
+ private File computeLockFile()
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), ".lock");
+ }
+
+ private File computePersistDir(SegmentIdWithShardSpec identifier)
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
+ }
+
+ private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
+ }
+
+ private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), "descriptor.json");
+ }
+
+ private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
+ {
+ final File persistDir = computePersistDir(identifier);
+ org.apache.commons.io.FileUtils.forceMkdir(persistDir);
+
+ objectMapper.writeValue(computeIdentifierFile(identifier), identifier);
+
+ return persistDir;
+ }
+
+ /**
+ * Persists the given hydrant and returns the number of rows persisted. Must only be called in the single-threaded
+ * persistExecutor.
+ *
+ * @param indexToPersist hydrant to persist
+ * @param identifier the segment this hydrant is going to be part of
+ * @return the number of rows persisted
+ */
+ private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
+ {
+ synchronized (indexToPersist) {
+ if (indexToPersist.hasSwapped()) {
+ log.info(
+ "Segment[%s] hydrant[%s] already swapped. Ignoring request to persist.",
+ identifier,
+ indexToPersist
+ );
+ return 0;
+ }
+
+ log.debug("Segment[%s], persisting Hydrant[%s]", identifier, indexToPersist);
+
+ try {
+ final long startTime = System.nanoTime();
+ int numRows = indexToPersist.getIndex().size();
+
+ // since the sink may have been persisted before it may have lost its
+ // hydrant count, we remember that value in the sinks metadata so we have
+ // to pull it from there....
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ final File persistDir = createPersistDirIfNeeded(identifier);
+ indexMerger.persist(
+ indexToPersist.getIndex(),
+ identifier.getInterval(),
+ new File(persistDir, String.valueOf(sm.getNumHydrants())),
+ tuningConfig.getIndexSpecForIntermediatePersists(),
+ tuningConfig.getSegmentWriteOutMediumFactory()
+ );
+
+ log.info(
+ "Persisted in-memory data for segment[%s] spill[%s] to disk in [%,d] ms (%,d rows).",
+ indexToPersist.getSegmentId(),
+ indexToPersist.getCount(),
+ (System.nanoTime() - startTime) / 1000000,
+ numRows
+ );
+
+ indexToPersist.swapSegment(null);
+ // remember hydrant count:
+ sinksMetadata.get(identifier).addHydrants(1);
+
+ return numRows;
+ }
+ catch (IOException e) {
+ log.makeAlert("Incremental persist failed")
+ .addData("segment", identifier.toString())
+ .addData("dataSource", schema.getDataSource())
+ .addData("count", indexToPersist.getCount())
+ .emit();
+
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void removeDirectory(final File target)
+ {
+ if (target.exists()) {
+ try {
+ FileUtils.deleteDirectory(target);
+ log.info("Removed directory [%s]", target);
+ }
+ catch (Exception e) {
+ log.makeAlert(e, "Failed to remove directory[%s]", schema.getDataSource())
+ .addData("file", target)
+ .emit();
+ }
+ }
+ }
+
+ private int calculateMemoryUsedByHydrants(FireHydrant hydrant)
+ {
+ if (skipBytesInMemoryOverheadCheck) {
+ return 0;
+ }
+ // These calculations are approximated from actual heap dumps.
+ // Memory footprint includes count integer in FireHydrant, shorts in ReferenceCountingSegment,
+ // Objects in SimpleQueryableIndex (such as SmooshedFileMapper, each ColumnHolder in column map, etc.)
+ int total;
+ total = Integer.BYTES + (4 * Short.BYTES) + ROUGH_OVERHEAD_PER_HYDRANT;
Review comment:
Yeah, it is good enough. Before it used to track memory used by memory mapped references which are no longer there.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
Review comment:
`persistAllAndClear` uses its own executor so I think it is ok where it is...
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
Review comment:
The key thing is that `persistAllAndClear` needs to be called and *complete* before push. Basically nothing should be concurrent in `BatchAppenderator`. We should remove all this concurrent looking code because it is confusing but as of now that will be done in future work.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658472584
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderators.java
##########
@@ -108,7 +108,28 @@ public static Appenderator createOffline(
boolean batchMemoryMappedIndex
)
{
- return new AppenderatorImpl(
+ if (batchMemoryMappedIndex) {
Review comment:
Unless we do a formal proof for correctness of a piece of code one can never be sure that code is bug free but this is not practical for this code. We have done the due diligence for this code: unit tests, integration tests, performance tests, soak/stress tests. Since the changes are deep, out of an abundance of caution, I still suggest having a fall back flag.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] lgtm-com[bot] commented on pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
lgtm-com[bot] commented on pull request #11294:
URL: https://github.com/apache/druid/pull/11294#issuecomment-868365635
This pull request **introduces 3 alerts** when merging afb61412360a5873cf5061a56ccc2590afec0ab8 into ed0a57e1063bd4da5700a7c5727cdaffcadac7e8 - [view on LGTM.com](https://lgtm.com/projects/g/apache/druid/rev/pr-7b5916f03af991c28661243d6f4f87f27ae85bf5)
**new alerts:**
* 3 for Unused format argument
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r661903917
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ return null;
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrant();
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, false);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed());
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData)
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ // Drop everything.
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), removeOnDiskData);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ removeSink(identifier, sink, true);
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ private void persistAllAndClear()
+ {
+ // make sure sinks are cleared before push is called
+ try {
+ persistAll(null).get();
+ clear(false);
+ }
+ catch (Throwable t) {
+ throw new RE(t, "Error while persisting");
+ }
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .filter(itp -> itp.rhs != null)
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ persistAllAndClear();
+
+ log.info("Preparing to push...");
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ if (persistedIdentifiers == null) {
+ throw new ISE("Identifiers were persisted but could not be retrieved");
+ }
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks;
+ try {
+ identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ }
+ catch (IOException e) {
+ throw new ISE(e, "Failed to retrieve sinks for identifier", identifier);
+ }
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+ log.info("Push complete...");
+
+ return Futures.immediateFuture(new SegmentsAndCommitMetadata(dataSegments, null));
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sm.getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), false);
+ }
+
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ if (persistedIdentifiers != null) {
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ Nothing to do since there are no executors
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @VisibleForTesting
+ @Nullable
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ private Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ throws IOException
+ {
+
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, IDENTIFIER_FILE_NAME),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+ if (sinkFiles == null) {
+ throw new ISE("Problem reading persisted sinks in path", identifierPath);
+ }
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ return new Pair<>(identifier, currSink);
+ }
+
+ private void removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed());
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrant());
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ if (removeOnDiskData) {
+ removeDirectory(computePersistDir(identifier));
+ }
+
+ log.info("Removed sink for segment[%s].", identifier);
+
+ }
+
+ private File computeLockFile()
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), ".lock");
+ }
+
+ private File computePersistDir(SegmentIdWithShardSpec identifier)
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
+ }
+
+ private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
+ }
+
+ private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), "descriptor.json");
+ }
+
+ private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
+ {
+ final File persistDir = computePersistDir(identifier);
+ org.apache.commons.io.FileUtils.forceMkdir(persistDir);
+
+ objectMapper.writeValue(computeIdentifierFile(identifier), identifier);
+
+ return persistDir;
+ }
+
+ /**
+ * Persists the given hydrant and returns the number of rows persisted.
+ *
+ * @param indexToPersist hydrant to persist
+ * @param identifier the segment this hydrant is going to be part of
+ * @return the number of rows persisted
+ */
+ private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
+ {
+ synchronized (indexToPersist) {
+ if (indexToPersist.hasSwapped()) {
+ log.info(
+ "Segment[%s] hydrant[%s] already swapped. Ignoring request to persist.",
+ identifier,
+ indexToPersist
+ );
+ return 0;
+ }
+
+ log.debug("Segment[%s], persisting Hydrant[%s]", identifier, indexToPersist);
+
+ try {
+ final long startTime = System.nanoTime();
+ int numRows = indexToPersist.getIndex().size();
+
+ // since the sink may have been persisted before it may have lost its
+ // hydrant count, we remember that value in the sinks metadata so we have
+ // to pull it from there....
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ throw new ISE("Sink must not be null for identifier when persisting hydrant", identifier);
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] jihoonson commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
jihoonson commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r665813513
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
Review comment:
It seems better to me to leave them separate since the overlord per sink and hydrant can be different from the stream ingestion in the future. Maybe even for now, since the sink can have up to only one hydrant before it is persisted, so memory pressure per sink could be different.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r666625047
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
+ {
+ if (partitionsSpec != null) {
+ return partitionsSpec;
+ }
+ return forceGuaranteedRollup
+ ? new HashedPartitionsSpec(null, null, null)
+ : new DynamicPartitionsSpec(null, null);
+ }
+
+ @Override
+ public IndexSpec getIndexSpec()
+ {
+ return indexSpec;
+ }
+
+ @Override
+ public IndexSpec getIndexSpecForIntermediatePersists()
+ {
+ return indexSpecForIntermediatePersists;
+ }
+
+ @Override
+ public int getMaxPendingPersists()
+ {
+ return maxPendingPersists;
+ }
+
+ public boolean isForceGuaranteedRollup()
+ {
+ return forceGuaranteedRollup;
+ }
+
+ @Override
+ public boolean isReportParseExceptions()
+ {
+ return reportParseExceptions;
+ }
+
+ @Nullable
+ @Override
+ public SegmentWriteOutMediumFactory getSegmentWriteOutMediumFactory()
+ {
+ return segmentWriteOutMediumFactory;
+ }
+
+ @Override
+ public int getMaxColumnsToMerge()
+ {
+ return maxColumnsToMerge;
+ }
+
+ public boolean isLogParseExceptions()
+ {
+ return logParseExceptions;
+ }
+
+ public int getMaxParseExceptions()
+ {
+ return maxParseExceptions;
+ }
+
+ public int getMaxSavedParseExceptions()
+ {
+ return maxSavedParseExceptions;
+ }
+
+ /**
+ * Return the max number of rows per segment. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Nullable
+ @Override
+ @Deprecated
+ public Integer getMaxRowsPerSegment()
+ {
+ return partitionsSpec == null ? null : partitionsSpec.getMaxRowsPerSegment();
+ }
+
+ /**
+ * Return the max number of total rows in appenderator. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Override
+ @Nullable
+ @Deprecated
+ public Long getMaxTotalRows()
+ {
+ return partitionsSpec instanceof DynamicPartitionsSpec
+ ? ((DynamicPartitionsSpec) partitionsSpec).getMaxTotalRows()
+ : null;
+ }
+
+ @Deprecated
+ @Nullable
+ public Integer getNumShards()
+ {
+ return partitionsSpec instanceof HashedPartitionsSpec
+ ? ((HashedPartitionsSpec) partitionsSpec).getNumShards()
+ : null;
+ }
+
+ @Deprecated
+ public List<String> getPartitionDimensions()
+ {
+ return partitionsSpec instanceof HashedPartitionsSpec
+ ? ((HashedPartitionsSpec) partitionsSpec).getPartitionDimensions()
+ : Collections.emptyList();
+ }
+
+ @Override
+ public File getBasePersistDirectory()
+ {
+ return basePersistDirectory;
+ }
+
+ @Override
+ public Period getIntermediatePersistPeriod()
+ {
+ return new Period(Integer.MAX_VALUE); // intermediate persist doesn't make much sense for batch jobs
+ }
+
+
+ public long getAwaitSegmentAvailabilityTimeoutMillis()
Review comment:
Removed
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r665806800
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
Review comment:
Left them as is since I don't think it is a good idea to start coupling back either to the interface or StreamAppenderator
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r662709315
##########
File path: indexing-service/src/test/java/org/apache/druid/indexing/appenderator/BatchAppenderatorDriverTest.java
##########
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.druid.segment.realtime.appenderator;
+package org.apache.druid.indexing.appenderator;
Review comment:
Removed class from exclusion after finding a way to move the test classes to the server module.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658528575
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
Review comment:
removed executors
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658477858
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderator.java
##########
@@ -235,7 +238,7 @@ AppenderatorAddResult add(
private final int numRowsInSegment;
private final boolean isPersistRequired;
- AppenderatorAddResult(
+ public AppenderatorAddResult(
Review comment:
They are needed in `BatchAppenderatorDriverTest` which is in a different module
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r665817837
##########
File path: docs/configuration/index.md
##########
@@ -1334,7 +1334,7 @@ Additional peon configs include:
|`druid.peon.mode`|Choices are "local" and "remote". Setting this to local means you intend to run the peon as a standalone process (Not recommended).|remote|
|`druid.indexer.task.baseDir`|Base temporary working directory.|`System.getProperty("java.io.tmpdir")`|
|`druid.indexer.task.baseTaskDir`|Base temporary working directory for tasks.|`${druid.indexer.task.baseDir}/persistent/task`|
-|`druid.indexer.task.batchMemoryMappedIndex`|If false, native batch ingestion will not map indexes thus saving heap space. This does not apply to streaming ingestion, just to batch. This setting should only be used when a bug is suspected or found in the new batch ingestion code that avoids memory mapping indices. If a bug is suspected or found, you can set this flag to `true` to fall back to previous, working but more memory intensive, code path.|`false`|
+|`druid.indexer.task.batchFallback`|If false, native batch ingestion will use memory optimized code. This does not apply to streaming ingestion, just to batch. This setting should only be used when a bug is suspected or found in the new optimized batch ingestion code. If a bug is suspected or found, you can set this flag to `true` to fall back to previous, working but more memory intensive, code path.|`false`|
Review comment:
Renamed to useLegacyBatchProcessing
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] jihoonson commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
jihoonson commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658301515
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderators.java
##########
@@ -108,7 +108,28 @@ public static Appenderator createOffline(
boolean batchMemoryMappedIndex
)
{
- return new AppenderatorImpl(
+ if (batchMemoryMappedIndex) {
+ // fallback to code know to be working, this is just a fallback option in case new
+ // batch appenderator has some early bugs but we will remove this fallback as soon as
+ // we determine that batch appenderator code is stable
Review comment:
How can we determine that the new code is stable? Is there anything you are imagining what kind of testings we must do?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658477956
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java
##########
@@ -172,7 +172,7 @@ SegmentWithState getAppendingSegment()
/**
* Allocated segments for a sequence
*/
- static class SegmentsForSequence
+ public static class SegmentsForSequence
Review comment:
They are needed in BatchAppenderatorDriverTest which is in a different module. Annotated that it is visible for testing.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r666600126
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
Review comment:
Removed
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658477072
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java
##########
@@ -260,8 +260,7 @@ SegmentsOfInterval get(long timestamp)
);
}
- @VisibleForTesting
Review comment:
Added annotation back
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r655795569
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ //objectMapper.writeValue(descriptorFile, segment);
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ //sinks.put(identifier, currSink);
Review comment:
done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r666627629
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
+ {
+ if (partitionsSpec != null) {
+ return partitionsSpec;
+ }
+ return forceGuaranteedRollup
+ ? new HashedPartitionsSpec(null, null, null)
+ : new DynamicPartitionsSpec(null, null);
+ }
+
+ @Override
+ public IndexSpec getIndexSpec()
+ {
+ return indexSpec;
+ }
+
+ @Override
+ public IndexSpec getIndexSpecForIntermediatePersists()
+ {
+ return indexSpecForIntermediatePersists;
+ }
+
+ @Override
+ public int getMaxPendingPersists()
+ {
+ return maxPendingPersists;
+ }
+
+ public boolean isForceGuaranteedRollup()
+ {
+ return forceGuaranteedRollup;
+ }
+
+ @Override
+ public boolean isReportParseExceptions()
+ {
+ return reportParseExceptions;
+ }
+
+ @Nullable
+ @Override
+ public SegmentWriteOutMediumFactory getSegmentWriteOutMediumFactory()
+ {
+ return segmentWriteOutMediumFactory;
+ }
+
+ @Override
+ public int getMaxColumnsToMerge()
+ {
+ return maxColumnsToMerge;
+ }
+
+ public boolean isLogParseExceptions()
+ {
+ return logParseExceptions;
+ }
+
+ public int getMaxParseExceptions()
+ {
+ return maxParseExceptions;
+ }
+
+ public int getMaxSavedParseExceptions()
+ {
+ return maxSavedParseExceptions;
+ }
+
+ /**
+ * Return the max number of rows per segment. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Nullable
+ @Override
+ @Deprecated
+ public Integer getMaxRowsPerSegment()
+ {
+ return partitionsSpec == null ? null : partitionsSpec.getMaxRowsPerSegment();
+ }
+
+ /**
+ * Return the max number of total rows in appenderator. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Override
+ @Nullable
+ @Deprecated
+ public Long getMaxTotalRows()
+ {
+ return partitionsSpec instanceof DynamicPartitionsSpec
+ ? ((DynamicPartitionsSpec) partitionsSpec).getMaxTotalRows()
+ : null;
+ }
+
+ @Deprecated
+ @Nullable
+ public Integer getNumShards()
+ {
+ return partitionsSpec instanceof HashedPartitionsSpec
+ ? ((HashedPartitionsSpec) partitionsSpec).getNumShards()
+ : null;
+ }
+
+ @Deprecated
+ public List<String> getPartitionDimensions()
Review comment:
removed
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r655796496
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ //objectMapper.writeValue(descriptorFile, segment);
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ //sinks.put(identifier, currSink);
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
+ log.makeAlert(e, "Problem loading sink[%s] from disk.", schema.getDataSource())
+ .addData("identifier path", identifierPath)
+ .emit();
+ }
+ return null;
+ }
+
+ private ListenableFuture<?> removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed(sink));
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrants(hydrant));
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+ // Wait for any outstanding pushes to finish, then abandon the segment inside the persist thread.
+ return Futures.transform(
+ pushBarrier(),
+ new Function<Object, Void>()
+ {
+ @Nullable
+ @Override
+ public Void apply(@Nullable Object input)
+ {
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ return null;
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ for (FireHydrant hydrant : sink) {
+ if (cache != null) {
+ cache.close(SinkQuerySegmentWalker.makeHydrantCacheIdentifier(hydrant));
+ }
+ hydrant.swapSegment(null);
+ }
+
+ if (removeOnDiskData) {
+ removeDirectory(computePersistDir(identifier));
+ }
+
+ log.info("Removed sink for segment[%s].", identifier);
+
+ return null;
+ }
+ },
+ // use persistExecutor to make sure that all the pending persists completes before
+ // starting to abandon segments
+ persistExecutor
+ );
+ }
+
+ private File computeLockFile()
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), ".lock");
+ }
+
+ private File computePersistDir(SegmentIdWithShardSpec identifier)
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
+ }
+
+ private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
+ }
+
+ private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), "descriptor.json");
+ }
+
+ private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
+ {
+ final File persistDir = computePersistDir(identifier);
+ org.apache.commons.io.FileUtils.forceMkdir(persistDir);
+
+ objectMapper.writeValue(computeIdentifierFile(identifier), identifier);
+
+ return persistDir;
+ }
+
+ /**
+ * Persists the given hydrant and returns the number of rows persisted. Must only be called in the single-threaded
+ * persistExecutor.
+ *
+ * @param indexToPersist hydrant to persist
+ * @param identifier the segment this hydrant is going to be part of
+ * @return the number of rows persisted
+ */
+ private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
+ {
+ synchronized (indexToPersist) {
+ if (indexToPersist.hasSwapped()) {
+ log.info(
+ "Segment[%s] hydrant[%s] already swapped. Ignoring request to persist.",
+ identifier,
+ indexToPersist
+ );
+ return 0;
+ }
+
+ log.debug("Segment[%s], persisting Hydrant[%s]", identifier, indexToPersist);
+
+ try {
+ final long startTime = System.nanoTime();
+ int numRows = indexToPersist.getIndex().size();
+
+ // since the sink may have been persisted before it may have lost its
+ // hydrant count, we remember that value in the sinks metadata so we have
+ // to pull it from there....
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ final File persistDir = createPersistDirIfNeeded(identifier);
+ indexMerger.persist(
+ indexToPersist.getIndex(),
+ identifier.getInterval(),
+ new File(persistDir, String.valueOf(sm.getNumHydrants())),
+ tuningConfig.getIndexSpecForIntermediatePersists(),
+ tuningConfig.getSegmentWriteOutMediumFactory()
+ );
+
+ log.info(
+ "Persisted in-memory data for segment[%s] spill[%s] to disk in [%,d] ms (%,d rows).",
+ indexToPersist.getSegmentId(),
+ indexToPersist.getCount(),
+ (System.nanoTime() - startTime) / 1000000,
+ numRows
+ );
+
+ indexToPersist.swapSegment(null);
+ // remember hydrant count:
+ sinksMetadata.get(identifier).addHydrants(1);
+
+ return numRows;
+ }
+ catch (IOException e) {
+ log.makeAlert("Incremental persist failed")
+ .addData("segment", identifier.toString())
+ .addData("dataSource", schema.getDataSource())
+ .addData("count", indexToPersist.getCount())
+ .emit();
+
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void removeDirectory(final File target)
+ {
+ if (target.exists()) {
+ try {
+ FileUtils.deleteDirectory(target);
+ log.info("Removed directory [%s]", target);
+ }
+ catch (Exception e) {
+ log.makeAlert(e, "Failed to remove directory[%s]", schema.getDataSource())
+ .addData("file", target)
+ .emit();
+ }
+ }
+ }
+
+ private int calculateMemoryUsedByHydrants(FireHydrant hydrant)
+ {
+ if (skipBytesInMemoryOverheadCheck) {
+ return 0;
+ }
+ // These calculations are approximated from actual heap dumps.
+ // Memory footprint includes count integer in FireHydrant, shorts in ReferenceCountingSegment,
+ // Objects in SimpleQueryableIndex (such as SmooshedFileMapper, each ColumnHolder in column map, etc.)
+ int total;
+ total = Integer.BYTES + (4 * Short.BYTES) + ROUGH_OVERHEAD_PER_HYDRANT;
Review comment:
Yeah, it is good enough. Before it used to track memory used by memory mapped references which are no longer there.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r664967315
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderator.java
##########
@@ -166,7 +166,16 @@
private volatile Throwable persistError;
+
+ /**
+ * Flag to tell internals whether appenderator is working on behalf of a real time task.
+ * This is to manage certain aspects as needed. For example, for batch, non-real time tasks,
+ * physical segments (i.e. hydrants) do not need to memory map their persisted
+ * files. In this case, the code will avoid memory mapping them thus ameliorating the occurance
+ * of OOMs.
+ */
private final boolean isRealTime;
Review comment:
It is used by the fall back flag.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r661903006
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r655797342
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
Review comment:
`persistAllAndClear` uses its own executor so I think it is ok where it is...
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658525270
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
Review comment:
Removed
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] clintropolis commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
clintropolis commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r664943961
##########
File path: docs/configuration/index.md
##########
@@ -1334,7 +1334,7 @@ Additional peon configs include:
|`druid.peon.mode`|Choices are "local" and "remote". Setting this to local means you intend to run the peon as a standalone process (Not recommended).|remote|
|`druid.indexer.task.baseDir`|Base temporary working directory.|`System.getProperty("java.io.tmpdir")`|
|`druid.indexer.task.baseTaskDir`|Base temporary working directory for tasks.|`${druid.indexer.task.baseDir}/persistent/task`|
-|`druid.indexer.task.batchMemoryMappedIndex`|If false, native batch ingestion will not map indexes thus saving heap space. This does not apply to streaming ingestion, just to batch. This setting should only be used when a bug is suspected or found in the new batch ingestion code that avoids memory mapping indices. If a bug is suspected or found, you can set this flag to `true` to fall back to previous, working but more memory intensive, code path.|`false`|
+|`druid.indexer.task.batchFallback`|If false, native batch ingestion will use memory optimized code. This does not apply to streaming ingestion, just to batch. This setting should only be used when a bug is suspected or found in the new optimized batch ingestion code. If a bug is suspected or found, you can set this flag to `true` to fall back to previous, working but more memory intensive, code path.|`false`|
Review comment:
I think this isn't a very intuitive name, how about something like `druid.indexer.task.useDedicatedBatchProcessing`, defaulting to `true` which is a hassle because it inverts the config.
>If true, native batch ingestion will use dedicated, memory optimized processing. When set to false, native batch indexing will revert to its legacy mode, which shares the same code-path as streaming ingestion but has a higher memory footprint.
If you would rather not invert usages because I admit it might be sort of painful to change, I guess something like `useLegacyBatchProcessing` or similar could also work and still allow defaulting to false and also be more clear about the role of the config when encountered in the properties file
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
Review comment:
could you please add javadocs clearly documented the expected concurrency model of this thing? Comparing with the stream appenderator, things like `persistHydrant` are synchronized, but that method is not here, which makes me think it should be only called by a single thread.
However, there are things like concurrent maps and atomic integer counters in use, which makes me curious if there is some concurrency, and what might be affected. If concurrency is _never_ expected, please remove the concurrent types because they are confusing.
Such a javadoc would save myself and any others from having to dig deep to try and trace this out for ourselves, so it would be helpful to clarify the concurrency model and if this diverges anywhere from the base `Appenderator` contractor or not.
Also, comparing side by side with `StreamAppenderator`, it looks like this class shares some lineage with it, it might be worth describing the differences in the javadocs here as well and linking to it (`StreamingAppenderator` would be nice too, but it didn't previously have javadocs so they are probably ok to add later...).
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,859 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.column.ColumnConfig;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
Review comment:
what is the difference between this and `StreamAppenderatorTester`, `Appenderators.createRealtime` vs `Appenderators.createOffline` and different tuning config? Also, does it need these json annotations?
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
Review comment:
nit: maybe put inline class at end of file so its not in middle of private fields declaration
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
Review comment:
nit: these seem dupes of constants in `StreamAppenderator`, should it just use them directly?
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderator.java
##########
@@ -166,7 +166,16 @@
private volatile Throwable persistError;
+
+ /**
+ * Flag to tell internals whether appenderator is working on behalf of a real time task.
+ * This is to manage certain aspects as needed. For example, for batch, non-real time tasks,
+ * physical segments (i.e. hydrants) do not need to memory map their persisted
+ * files. In this case, the code will avoid memory mapping them thus ameliorating the occurance
+ * of OOMs.
+ */
private final boolean isRealTime;
Review comment:
it seems like this should just be removed? Since this functionality hasn't been released, should it still be here? I guess it could be removed in a follow-up, but I guess it also means there is no way to turn _this_ functionality off for batch tasks in case closing the segments in `StreamAppenderator` itself has a bug.
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ //objectMapper.writeValue(descriptorFile, segment);
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ //sinks.put(identifier, currSink);
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
+ log.makeAlert(e, "Problem loading sink[%s] from disk.", schema.getDataSource())
+ .addData("identifier path", identifierPath)
+ .emit();
+ }
+ return null;
+ }
+
+ private ListenableFuture<?> removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed(sink));
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrants(hydrant));
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+ // Wait for any outstanding pushes to finish, then abandon the segment inside the persist thread.
+ return Futures.transform(
+ pushBarrier(),
+ new Function<Object, Void>()
+ {
+ @Nullable
+ @Override
+ public Void apply(@Nullable Object input)
+ {
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ return null;
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ for (FireHydrant hydrant : sink) {
+ if (cache != null) {
+ cache.close(SinkQuerySegmentWalker.makeHydrantCacheIdentifier(hydrant));
+ }
+ hydrant.swapSegment(null);
+ }
+
+ if (removeOnDiskData) {
+ removeDirectory(computePersistDir(identifier));
+ }
+
+ log.info("Removed sink for segment[%s].", identifier);
+
+ return null;
+ }
+ },
+ // use persistExecutor to make sure that all the pending persists completes before
+ // starting to abandon segments
+ persistExecutor
+ );
+ }
+
+ private File computeLockFile()
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), ".lock");
+ }
+
+ private File computePersistDir(SegmentIdWithShardSpec identifier)
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
+ }
+
+ private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
+ }
+
+ private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), "descriptor.json");
+ }
+
+ private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
+ {
+ final File persistDir = computePersistDir(identifier);
+ org.apache.commons.io.FileUtils.forceMkdir(persistDir);
+
+ objectMapper.writeValue(computeIdentifierFile(identifier), identifier);
+
+ return persistDir;
+ }
+
+ /**
+ * Persists the given hydrant and returns the number of rows persisted. Must only be called in the single-threaded
+ * persistExecutor.
+ *
+ * @param indexToPersist hydrant to persist
+ * @param identifier the segment this hydrant is going to be part of
+ * @return the number of rows persisted
+ */
+ private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
+ {
+ synchronized (indexToPersist) {
+ if (indexToPersist.hasSwapped()) {
+ log.info(
+ "Segment[%s] hydrant[%s] already swapped. Ignoring request to persist.",
+ identifier,
+ indexToPersist
+ );
+ return 0;
+ }
+
+ log.debug("Segment[%s], persisting Hydrant[%s]", identifier, indexToPersist);
+
+ try {
+ final long startTime = System.nanoTime();
+ int numRows = indexToPersist.getIndex().size();
+
+ // since the sink may have been persisted before it may have lost its
+ // hydrant count, we remember that value in the sinks metadata so we have
+ // to pull it from there....
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ final File persistDir = createPersistDirIfNeeded(identifier);
+ indexMerger.persist(
+ indexToPersist.getIndex(),
+ identifier.getInterval(),
+ new File(persistDir, String.valueOf(sm.getNumHydrants())),
+ tuningConfig.getIndexSpecForIntermediatePersists(),
+ tuningConfig.getSegmentWriteOutMediumFactory()
+ );
+
+ log.info(
+ "Persisted in-memory data for segment[%s] spill[%s] to disk in [%,d] ms (%,d rows).",
+ indexToPersist.getSegmentId(),
+ indexToPersist.getCount(),
+ (System.nanoTime() - startTime) / 1000000,
+ numRows
+ );
+
+ indexToPersist.swapSegment(null);
+ // remember hydrant count:
+ sinksMetadata.get(identifier).addHydrants(1);
+
+ return numRows;
+ }
+ catch (IOException e) {
+ log.makeAlert("Incremental persist failed")
+ .addData("segment", identifier.toString())
+ .addData("dataSource", schema.getDataSource())
+ .addData("count", indexToPersist.getCount())
+ .emit();
+
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void removeDirectory(final File target)
+ {
+ if (target.exists()) {
+ try {
+ FileUtils.deleteDirectory(target);
+ log.info("Removed directory [%s]", target);
+ }
+ catch (Exception e) {
+ log.makeAlert(e, "Failed to remove directory[%s]", schema.getDataSource())
+ .addData("file", target)
+ .emit();
+ }
+ }
+ }
+
+ private int calculateMemoryUsedByHydrants(FireHydrant hydrant)
+ {
+ if (skipBytesInMemoryOverheadCheck) {
+ return 0;
+ }
+ // These calculations are approximated from actual heap dumps.
+ // Memory footprint includes count integer in FireHydrant, shorts in ReferenceCountingSegment,
+ // Objects in SimpleQueryableIndex (such as SmooshedFileMapper, each ColumnHolder in column map, etc.)
+ int total;
+ total = Integer.BYTES + (4 * Short.BYTES) + ROUGH_OVERHEAD_PER_HYDRANT;
Review comment:
nit: seems like a lot of lines for a constant. if i understand correctly there is only 1 hydrant per sink, would it just make sense to factor this into the sink calculation?
Also the comment doesn't seem relevant and should be fixed or removed
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658485021
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
+ log.makeAlert(e, "Problem loading sink[%s] from disk.", schema.getDataSource())
+ .addData("identifier path", identifierPath)
+ .emit();
+ }
+ return null;
+ }
+
+ private ListenableFuture<?> removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed(sink));
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrants(hydrant));
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+ // Wait for any outstanding pushes to finish, then abandon the segment inside the persist thread.
+ return Futures.transform(
+ pushBarrier(),
+ new Function<Object, Void>()
+ {
+ @Nullable
+ @Override
+ public Void apply(@Nullable Object input)
+ {
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ return null;
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ if (removeOnDiskData) {
+ removeDirectory(computePersistDir(identifier));
+ }
+
+ log.info("Removed sink for segment[%s].", identifier);
+
+ return null;
+ }
+ },
+ // use persistExecutor to make sure that all the pending persists completes before
+ // starting to abandon segments
+ persistExecutor
+ );
+ }
+
+ private File computeLockFile()
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), ".lock");
+ }
+
+ private File computePersistDir(SegmentIdWithShardSpec identifier)
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
+ }
+
+ private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
+ }
+
+ private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), "descriptor.json");
+ }
+
+ private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
+ {
+ final File persistDir = computePersistDir(identifier);
+ org.apache.commons.io.FileUtils.forceMkdir(persistDir);
+
+ objectMapper.writeValue(computeIdentifierFile(identifier), identifier);
+
+ return persistDir;
+ }
+
+ /**
+ * Persists the given hydrant and returns the number of rows persisted. Must only be called in the single-threaded
+ * persistExecutor.
+ *
+ * @param indexToPersist hydrant to persist
+ * @param identifier the segment this hydrant is going to be part of
+ * @return the number of rows persisted
+ */
+ private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
+ {
+ synchronized (indexToPersist) {
+ if (indexToPersist.hasSwapped()) {
+ log.info(
+ "Segment[%s] hydrant[%s] already swapped. Ignoring request to persist.",
+ identifier,
+ indexToPersist
+ );
+ return 0;
+ }
+
+ log.debug("Segment[%s], persisting Hydrant[%s]", identifier, indexToPersist);
+
+ try {
+ final long startTime = System.nanoTime();
+ int numRows = indexToPersist.getIndex().size();
+
+ // since the sink may have been persisted before it may have lost its
+ // hydrant count, we remember that value in the sinks metadata so we have
+ // to pull it from there....
+ SinkMetadata sm = sinksMetadata.get(identifier);
Review comment:
done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658485557
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
Review comment:
done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658532863
##########
File path: server/pom.xml
##########
@@ -470,6 +470,7 @@
<excludes>
<!-- There are UTs for this class but it is very difficult to get required branch coverage -->
<exclude>org/apache/druid/metadata/BasicDataSourceExt.class</exclude>
+ <exclude>org/apache/druid/segment/realtime/appenderator/BatchAppenderator.class</exclude>
Review comment:
It was very difficult to get rid of the coverage errors...let me add it back and let's see...
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658482139
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r664967140
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
Review comment:
I don't think we want to use stuff from StreamAppenderator but I could move them to the Appenderator interface
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r661752645
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderators.java
##########
@@ -108,7 +108,28 @@ public static Appenderator createOffline(
boolean batchMemoryMappedIndex
)
{
- return new AppenderatorImpl(
+ if (batchMemoryMappedIndex) {
Review comment:
Yes, only one flag remains.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] maytasm commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
maytasm commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r655019113
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ //objectMapper.writeValue(descriptorFile, segment);
Review comment:
Why is this commented out?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r661914520
##########
File path: indexing-service/src/test/java/org/apache/druid/indexing/appenderator/BatchAppenderatorDriverTest.java
##########
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.druid.segment.realtime.appenderator;
+package org.apache.druid.indexing.appenderator;
Review comment:
Class `BatchAppenderatorTester` that must be moved also if we want to move the test classes to the `server` module is very difficult to move because it uses the constructor for class `IndexTask.IndexTuningConfig` which is not available in the server module. Moving that class will demand moving a lot of classes that do not make sense in the `server` module.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658472584
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderators.java
##########
@@ -108,7 +108,28 @@ public static Appenderator createOffline(
boolean batchMemoryMappedIndex
)
{
- return new AppenderatorImpl(
+ if (batchMemoryMappedIndex) {
Review comment:
Unless we do a formal proof for correctness of a piece of code one can never be sure that code is bug free but this is not practical for this code. We have done the due diligence for this code: unit tests, integration tests, performance tests, soak/stress tests. Since the changes are deep and this area of code is critical for batch ingestion, out of an abundance of caution, I still suggest having a fall back flag.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r665806415
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
Review comment:
Added java doc and removed remaining concurrency constructs
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] clintropolis commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
clintropolis commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r664973951
##########
File path: docs/configuration/index.md
##########
@@ -1334,7 +1334,7 @@ Additional peon configs include:
|`druid.peon.mode`|Choices are "local" and "remote". Setting this to local means you intend to run the peon as a standalone process (Not recommended).|remote|
|`druid.indexer.task.baseDir`|Base temporary working directory.|`System.getProperty("java.io.tmpdir")`|
|`druid.indexer.task.baseTaskDir`|Base temporary working directory for tasks.|`${druid.indexer.task.baseDir}/persistent/task`|
-|`druid.indexer.task.batchMemoryMappedIndex`|If false, native batch ingestion will not map indexes thus saving heap space. This does not apply to streaming ingestion, just to batch. This setting should only be used when a bug is suspected or found in the new batch ingestion code that avoids memory mapping indices. If a bug is suspected or found, you can set this flag to `true` to fall back to previous, working but more memory intensive, code path.|`false`|
+|`druid.indexer.task.batchFallback`|If false, native batch ingestion will use memory optimized code. This does not apply to streaming ingestion, just to batch. This setting should only be used when a bug is suspected or found in the new optimized batch ingestion code. If a bug is suspected or found, you can set this flag to `true` to fall back to previous, working but more memory intensive, code path.|`false`|
Review comment:
I'm making the 0.22 branch likely in the next week, so it seems to me that the flag _must_ exist to provide a way to revert to 0.21 behavior for at least 1 release cycle I think. `batchMemoryMappedIndex` is not in 0.21, so has never been released.
Since this flag will be release, I still think I assert that it should have a better name, inverted or not, I don't see a good argument to leave it intentionally vague.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r666622948
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
Review comment:
Clean config as much as I could, take a look.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] jihoonson merged pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
jihoonson merged pull request #11294:
URL: https://github.com/apache/druid/pull/11294
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r661901615
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -604,48 +557,39 @@ private SegmentsAndCommitMetadata persistAllAndClear()
final Stopwatch runExecStopwatch = Stopwatch.createStarted();
final Stopwatch persistStopwatch = Stopwatch.createStarted();
AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
- final ListenableFuture<Object> future = persistExecutor.submit(
- new Callable<Object>()
- {
- @Override
- public Object call()
- {
- try {
- for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
- metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
- }
-
- log.info(
- "Persisted in-memory data for segments: %s",
- indexesToPersist.stream()
- .map(itp -> itp.rhs.asSegmentId().toString())
- .distinct()
- .collect(Collectors.joining(", "))
- );
- log.info(
- "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
- rowIngestionMeters.getProcessed(),
- totalPersistedRows.get(),
- totalSinks,
- totalHydrantsCount.longValue(),
- totalHydrantsPersistedAcrossSinks.longValue()
- );
-
- // return null if committer is null
- return null;
- }
- catch (Exception e) {
- metrics.incrementFailedPersists();
- throw e;
- }
- finally {
- metrics.incrementNumPersists();
- metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
- persistStopwatch.stop();
- }
- }
- }
- );
+
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .filter(itp -> itp.rhs != null)
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
metrics.incrementPersistBackPressureMillis(startDelay);
Review comment:
Done.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r666626820
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
+ {
+ if (partitionsSpec != null) {
+ return partitionsSpec;
+ }
+ return forceGuaranteedRollup
+ ? new HashedPartitionsSpec(null, null, null)
+ : new DynamicPartitionsSpec(null, null);
+ }
+
+ @Override
+ public IndexSpec getIndexSpec()
+ {
+ return indexSpec;
+ }
+
+ @Override
+ public IndexSpec getIndexSpecForIntermediatePersists()
+ {
+ return indexSpecForIntermediatePersists;
+ }
+
+ @Override
+ public int getMaxPendingPersists()
+ {
+ return maxPendingPersists;
+ }
+
+ public boolean isForceGuaranteedRollup()
+ {
+ return forceGuaranteedRollup;
+ }
+
+ @Override
+ public boolean isReportParseExceptions()
+ {
+ return reportParseExceptions;
+ }
+
+ @Nullable
+ @Override
+ public SegmentWriteOutMediumFactory getSegmentWriteOutMediumFactory()
+ {
+ return segmentWriteOutMediumFactory;
+ }
+
+ @Override
+ public int getMaxColumnsToMerge()
+ {
+ return maxColumnsToMerge;
+ }
+
+ public boolean isLogParseExceptions()
+ {
+ return logParseExceptions;
+ }
+
+ public int getMaxParseExceptions()
+ {
+ return maxParseExceptions;
+ }
+
+ public int getMaxSavedParseExceptions()
+ {
+ return maxSavedParseExceptions;
+ }
Review comment:
Removed
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r665805427
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,859 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.column.ColumnConfig;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean batchFallback
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new IndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null
+ ).withBasePersistDirectory(basePersistDirectory != null ? basePersistDirectory : createNewBasePersistDirectory());
+
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ new ColumnConfig()
+ {
+ @Override
+ public int columnCacheSizeBytes()
+ {
+ return 0;
+ }
+ }
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ batchFallback
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing as is for testing since it is not accessible from server module,
+ // we could simplify since not all its functionality is being used
+ // but leaving as is, it could be useful later
+ private static class IndexTuningConfig implements AppenderatorConfig
Review comment:
It is already simple as much as it can be. Most of the code is setting defaults that are necessary for appenderator to function. I would like to leave it as is.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r665807108
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,859 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.column.ColumnConfig;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
Review comment:
I decided to create different tester classes for stream & batch so as not to couple them together. I will remove the json annotations.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] maytasm commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
maytasm commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r655023977
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ //objectMapper.writeValue(descriptorFile, segment);
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ //sinks.put(identifier, currSink);
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
+ log.makeAlert(e, "Problem loading sink[%s] from disk.", schema.getDataSource())
+ .addData("identifier path", identifierPath)
+ .emit();
+ }
+ return null;
+ }
+
+ private ListenableFuture<?> removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed(sink));
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrants(hydrant));
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+ // Wait for any outstanding pushes to finish, then abandon the segment inside the persist thread.
+ return Futures.transform(
+ pushBarrier(),
+ new Function<Object, Void>()
+ {
+ @Nullable
+ @Override
+ public Void apply(@Nullable Object input)
+ {
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ return null;
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ for (FireHydrant hydrant : sink) {
+ if (cache != null) {
+ cache.close(SinkQuerySegmentWalker.makeHydrantCacheIdentifier(hydrant));
Review comment:
Is this needed?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r661903547
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658484045
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
Review comment:
done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r666623060
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
+ {
+ if (partitionsSpec != null) {
+ return partitionsSpec;
+ }
+ return forceGuaranteedRollup
+ ? new HashedPartitionsSpec(null, null, null)
+ : new DynamicPartitionsSpec(null, null);
+ }
+
+ @Override
+ public IndexSpec getIndexSpec()
+ {
+ return indexSpec;
+ }
+
+ @Override
+ public IndexSpec getIndexSpecForIntermediatePersists()
+ {
+ return indexSpecForIntermediatePersists;
+ }
+
+ @Override
+ public int getMaxPendingPersists()
+ {
+ return maxPendingPersists;
+ }
+
+ public boolean isForceGuaranteedRollup()
+ {
+ return forceGuaranteedRollup;
+ }
+
+ @Override
+ public boolean isReportParseExceptions()
+ {
+ return reportParseExceptions;
+ }
+
+ @Nullable
+ @Override
+ public SegmentWriteOutMediumFactory getSegmentWriteOutMediumFactory()
+ {
+ return segmentWriteOutMediumFactory;
+ }
+
+ @Override
+ public int getMaxColumnsToMerge()
+ {
+ return maxColumnsToMerge;
+ }
+
+ public boolean isLogParseExceptions()
+ {
+ return logParseExceptions;
+ }
+
+ public int getMaxParseExceptions()
+ {
+ return maxParseExceptions;
+ }
+
+ public int getMaxSavedParseExceptions()
+ {
+ return maxSavedParseExceptions;
+ }
+
+ /**
+ * Return the max number of rows per segment. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Nullable
+ @Override
+ @Deprecated
+ public Integer getMaxRowsPerSegment()
+ {
+ return partitionsSpec == null ? null : partitionsSpec.getMaxRowsPerSegment();
+ }
+
+ /**
+ * Return the max number of total rows in appenderator. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Override
+ @Nullable
+ @Deprecated
+ public Long getMaxTotalRows()
+ {
+ return partitionsSpec instanceof DynamicPartitionsSpec
+ ? ((DynamicPartitionsSpec) partitionsSpec).getMaxTotalRows()
+ : null;
+ }
+
+ @Deprecated
+ @Nullable
+ public Integer getNumShards()
Review comment:
Removed
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,774 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean useLegacyBatchProcessing
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new TestIndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null,
+ basePersistDirectory == null ? createNewBasePersistDirectory() : basePersistDirectory
+ );
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ () -> 0
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ DataSegmentPusher dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ useLegacyBatchProcessing
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing testing since it is not accessible from server module,
+ // Cleaned up a little but Leaving mostly as-is since most of the functionality is
+ // setting defaults when passing null and those defaults are
+ // required for the appenderator to work
+ private static class TestIndexTuningConfig implements AppenderatorConfig
+ {
+ private static final IndexSpec DEFAULT_INDEX_SPEC = new IndexSpec();
+ private static final int DEFAULT_MAX_PENDING_PERSISTS = 0;
+ private static final boolean DEFAULT_GUARANTEE_ROLLUP = false;
+ private static final boolean DEFAULT_REPORT_PARSE_EXCEPTIONS = false;
+ private static final long DEFAULT_PUSH_TIMEOUT = 0;
+
+ private final AppendableIndexSpec appendableIndexSpec;
+ private final int maxRowsInMemory;
+ private final long maxBytesInMemory;
+ private final boolean skipBytesInMemoryOverheadCheck;
+ private final int maxColumnsToMerge;
+
+ // null if all partitionsSpec related params are null. see getDefaultPartitionsSpec() for details.
+ @Nullable
+ private final PartitionsSpec partitionsSpec;
+ private final IndexSpec indexSpec;
+ private final IndexSpec indexSpecForIntermediatePersists;
+ private final File basePersistDirectory;
+ private final int maxPendingPersists;
+
+ private final boolean forceGuaranteedRollup;
+ private final boolean reportParseExceptions;
+ private final long pushTimeout;
+ private final boolean logParseExceptions;
+ private final int maxParseExceptions;
+ private final int maxSavedParseExceptions;
+ private final long awaitSegmentAvailabilityTimeoutMillis;
+
+ @Nullable
+ private final SegmentWriteOutMediumFactory segmentWriteOutMediumFactory;
+
+ @Nullable
+ private static PartitionsSpec getPartitionsSpec(
+ boolean forceGuaranteedRollup,
+ @Nullable PartitionsSpec partitionsSpec,
+ @Nullable Integer maxRowsPerSegment,
+ @Nullable Long maxTotalRows,
+ @Nullable Integer numShards,
+ @Nullable List<String> partitionDimensions
+ )
+ {
+ if (partitionsSpec == null) {
+ if (forceGuaranteedRollup) {
+ if (maxRowsPerSegment != null
+ || numShards != null
+ || (partitionDimensions != null && !partitionDimensions.isEmpty())) {
+ return new HashedPartitionsSpec(maxRowsPerSegment, numShards, partitionDimensions);
+ } else {
+ return null;
+ }
+ } else {
+ if (maxRowsPerSegment != null || maxTotalRows != null) {
+ return new DynamicPartitionsSpec(maxRowsPerSegment, maxTotalRows);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ if (forceGuaranteedRollup) {
+ if (!partitionsSpec.isForceGuaranteedRollupCompatibleType()) {
+ throw new IAE(partitionsSpec.getClass().getSimpleName() + " cannot be used for perfect rollup");
+ }
+ } else {
+ if (!(partitionsSpec instanceof DynamicPartitionsSpec)) {
+ throw new IAE("DynamicPartitionsSpec must be used for best-effort rollup");
+ }
+ }
+ return partitionsSpec;
+ }
+ }
+
+ public TestIndexTuningConfig(
+ Integer targetPartitionSize,
+ Integer maxRowsPerSegment,
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ Long maxTotalRows,
+ Integer rowFlushBoundary_forBackCompatibility,
+ Integer numShards,
+ List<String> partitionDimensions,
+ PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long publishTimeout,
+ Long pushTimeout,
+ SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis,
+ File basePersistDir
+ )
+ {
+ this(
+ appendableIndexSpec,
+ maxRowsInMemory != null ? maxRowsInMemory : rowFlushBoundary_forBackCompatibility,
+ maxBytesInMemory != null ? maxBytesInMemory : 0,
+ skipBytesInMemoryOverheadCheck != null
+ ? skipBytesInMemoryOverheadCheck
+ : DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK,
+ getPartitionsSpec(
+ forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup,
+ partitionsSpec,
+ maxRowsPerSegment == null ? targetPartitionSize : maxRowsPerSegment,
+ maxTotalRows,
+ numShards,
+ partitionDimensions
+ ),
+ indexSpec,
+ indexSpecForIntermediatePersists,
+ maxPendingPersists,
+ forceGuaranteedRollup,
+ reportParseExceptions,
+ pushTimeout != null ? pushTimeout : publishTimeout,
+ basePersistDir,
+ segmentWriteOutMediumFactory,
+ logParseExceptions,
+ maxParseExceptions,
+ maxSavedParseExceptions,
+ maxColumnsToMerge,
+ awaitSegmentAvailabilityTimeoutMillis
+ );
+
+ Preconditions.checkArgument(
+ targetPartitionSize == null || maxRowsPerSegment == null,
+ "Can't use targetPartitionSize and maxRowsPerSegment together"
+ );
+ }
+
+ private TestIndexTuningConfig(
+ AppendableIndexSpec appendableIndexSpec,
+ Integer maxRowsInMemory,
+ Long maxBytesInMemory,
+ Boolean skipBytesInMemoryOverheadCheck,
+ @Nullable PartitionsSpec partitionsSpec,
+ IndexSpec indexSpec,
+ IndexSpec indexSpecForIntermediatePersists,
+ Integer maxPendingPersists,
+ Boolean forceGuaranteedRollup,
+ Boolean reportParseExceptions,
+ Long pushTimeout,
+ File basePersistDirectory,
+ @Nullable SegmentWriteOutMediumFactory segmentWriteOutMediumFactory,
+ Boolean logParseExceptions,
+ Integer maxParseExceptions,
+ Integer maxSavedParseExceptions,
+ Integer maxColumnsToMerge,
+ Long awaitSegmentAvailabilityTimeoutMillis
+ )
+ {
+ this.appendableIndexSpec = appendableIndexSpec == null ? DEFAULT_APPENDABLE_INDEX : appendableIndexSpec;
+ this.maxRowsInMemory = maxRowsInMemory == null ? TuningConfig.DEFAULT_MAX_ROWS_IN_MEMORY : maxRowsInMemory;
+ // initializing this to 0, it will be lazily initialized to a value
+ // @see #getMaxBytesInMemoryOrDefault()
+ this.maxBytesInMemory = maxBytesInMemory == null ? 0 : maxBytesInMemory;
+ this.skipBytesInMemoryOverheadCheck = skipBytesInMemoryOverheadCheck == null
+ ?
+ DEFAULT_SKIP_BYTES_IN_MEMORY_OVERHEAD_CHECK
+ : skipBytesInMemoryOverheadCheck;
+ this.maxColumnsToMerge = maxColumnsToMerge == null
+ ? IndexMerger.UNLIMITED_MAX_COLUMNS_TO_MERGE
+ : maxColumnsToMerge;
+ this.partitionsSpec = partitionsSpec;
+ this.indexSpec = indexSpec == null ? DEFAULT_INDEX_SPEC : indexSpec;
+ this.indexSpecForIntermediatePersists = indexSpecForIntermediatePersists == null ?
+ this.indexSpec : indexSpecForIntermediatePersists;
+ this.maxPendingPersists = maxPendingPersists == null ? DEFAULT_MAX_PENDING_PERSISTS : maxPendingPersists;
+ this.forceGuaranteedRollup = forceGuaranteedRollup == null ? DEFAULT_GUARANTEE_ROLLUP : forceGuaranteedRollup;
+ this.reportParseExceptions = reportParseExceptions == null
+ ? DEFAULT_REPORT_PARSE_EXCEPTIONS
+ : reportParseExceptions;
+ this.pushTimeout = pushTimeout == null ? DEFAULT_PUSH_TIMEOUT : pushTimeout;
+ this.basePersistDirectory = basePersistDirectory;
+
+ this.segmentWriteOutMediumFactory = segmentWriteOutMediumFactory;
+
+ if (this.reportParseExceptions) {
+ this.maxParseExceptions = 0;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null ? 0 : Math.min(1, maxSavedParseExceptions);
+ } else {
+ this.maxParseExceptions = maxParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_PARSE_EXCEPTIONS
+ : maxParseExceptions;
+ this.maxSavedParseExceptions = maxSavedParseExceptions == null
+ ? TuningConfig.DEFAULT_MAX_SAVED_PARSE_EXCEPTIONS
+ : maxSavedParseExceptions;
+ }
+ this.logParseExceptions = logParseExceptions == null
+ ? TuningConfig.DEFAULT_LOG_PARSE_EXCEPTIONS
+ : logParseExceptions;
+ if (awaitSegmentAvailabilityTimeoutMillis == null || awaitSegmentAvailabilityTimeoutMillis < 0) {
+ this.awaitSegmentAvailabilityTimeoutMillis = DEFAULT_AWAIT_SEGMENT_AVAILABILITY_TIMEOUT_MILLIS;
+ } else {
+ this.awaitSegmentAvailabilityTimeoutMillis = awaitSegmentAvailabilityTimeoutMillis;
+ }
+ }
+
+ @Override
+ public TestIndexTuningConfig withBasePersistDirectory(File dir)
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public AppendableIndexSpec getAppendableIndexSpec()
+ {
+ return appendableIndexSpec;
+ }
+
+ @Override
+ public int getMaxRowsInMemory()
+ {
+ return maxRowsInMemory;
+ }
+
+ @Override
+ public long getMaxBytesInMemory()
+ {
+ return maxBytesInMemory;
+ }
+
+ @Override
+ public boolean isSkipBytesInMemoryOverheadCheck()
+ {
+ return skipBytesInMemoryOverheadCheck;
+ }
+
+ @Nullable
+ @Override
+ public PartitionsSpec getPartitionsSpec()
+ {
+ return partitionsSpec;
+ }
+
+ public PartitionsSpec getGivenOrDefaultPartitionsSpec()
+ {
+ if (partitionsSpec != null) {
+ return partitionsSpec;
+ }
+ return forceGuaranteedRollup
+ ? new HashedPartitionsSpec(null, null, null)
+ : new DynamicPartitionsSpec(null, null);
+ }
+
+ @Override
+ public IndexSpec getIndexSpec()
+ {
+ return indexSpec;
+ }
+
+ @Override
+ public IndexSpec getIndexSpecForIntermediatePersists()
+ {
+ return indexSpecForIntermediatePersists;
+ }
+
+ @Override
+ public int getMaxPendingPersists()
+ {
+ return maxPendingPersists;
+ }
+
+ public boolean isForceGuaranteedRollup()
+ {
+ return forceGuaranteedRollup;
+ }
+
+ @Override
+ public boolean isReportParseExceptions()
+ {
+ return reportParseExceptions;
+ }
+
+ @Nullable
+ @Override
+ public SegmentWriteOutMediumFactory getSegmentWriteOutMediumFactory()
+ {
+ return segmentWriteOutMediumFactory;
+ }
+
+ @Override
+ public int getMaxColumnsToMerge()
+ {
+ return maxColumnsToMerge;
+ }
+
+ public boolean isLogParseExceptions()
+ {
+ return logParseExceptions;
+ }
+
+ public int getMaxParseExceptions()
+ {
+ return maxParseExceptions;
+ }
+
+ public int getMaxSavedParseExceptions()
+ {
+ return maxSavedParseExceptions;
+ }
+
+ /**
+ * Return the max number of rows per segment. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Nullable
+ @Override
+ @Deprecated
+ public Integer getMaxRowsPerSegment()
+ {
+ return partitionsSpec == null ? null : partitionsSpec.getMaxRowsPerSegment();
+ }
+
+ /**
+ * Return the max number of total rows in appenderator. This returns null if it's not specified in tuningConfig.
+ * Deprecated in favor of {@link #getGivenOrDefaultPartitionsSpec()}.
+ */
+ @Override
+ @Nullable
+ @Deprecated
Review comment:
Fixed
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658476765
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderators.java
##########
@@ -108,7 +108,28 @@ public static Appenderator createOffline(
boolean batchMemoryMappedIndex
)
{
- return new AppenderatorImpl(
+ if (batchMemoryMappedIndex) {
+ // fallback to code know to be working, this is just a fallback option in case new
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658483919
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
Review comment:
done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658482536
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] maytasm commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
maytasm commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r655021575
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ //objectMapper.writeValue(descriptorFile, segment);
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ //sinks.put(identifier, currSink);
Review comment:
remove?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r665805427
##########
File path: server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorTester.java
##########
@@ -0,0 +1,859 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Preconditions;
+import org.apache.druid.data.input.impl.DimensionsSpec;
+import org.apache.druid.data.input.impl.JSONParseSpec;
+import org.apache.druid.data.input.impl.MapInputRowParser;
+import org.apache.druid.data.input.impl.TimestampSpec;
+import org.apache.druid.indexer.partitions.DynamicPartitionsSpec;
+import org.apache.druid.indexer.partitions.HashedPartitionsSpec;
+import org.apache.druid.indexer.partitions.PartitionsSpec;
+import org.apache.druid.jackson.DefaultObjectMapper;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.granularity.Granularities;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.java.util.emitter.core.NoopEmitter;
+import org.apache.druid.java.util.emitter.service.ServiceEmitter;
+import org.apache.druid.query.aggregation.AggregatorFactory;
+import org.apache.druid.query.aggregation.CountAggregatorFactory;
+import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.IndexMergerV9;
+import org.apache.druid.segment.IndexSpec;
+import org.apache.druid.segment.column.ColumnConfig;
+import org.apache.druid.segment.incremental.AppendableIndexSpec;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.incremental.SimpleRowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.indexing.TuningConfig;
+import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.partition.LinearShardSpec;
+import org.joda.time.Period;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class BatchAppenderatorTester implements AutoCloseable
+{
+ public static final String DATASOURCE = "foo";
+
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final Appenderator appenderator;
+ private final ServiceEmitter emitter;
+
+ private final List<DataSegment> pushedSegments = new CopyOnWriteArrayList<>();
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory
+ )
+ {
+ this(maxRowsInMemory, -1, null, false);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, -1, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final boolean enablePushFailure
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, null, enablePushFailure);
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ final File basePersistDirectory,
+ final boolean enablePushFailure
+ )
+ {
+ this(
+ maxRowsInMemory,
+ maxSizeInBytes,
+ basePersistDirectory,
+ enablePushFailure,
+ new SimpleRowIngestionMeters(),
+ false,
+ false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters
+ )
+ {
+ this(maxRowsInMemory, maxSizeInBytes, basePersistDirectory, enablePushFailure, rowIngestionMeters,
+ false, false
+ );
+ }
+
+ public BatchAppenderatorTester(
+ final int maxRowsInMemory,
+ final long maxSizeInBytes,
+ @Nullable final File basePersistDirectory,
+ final boolean enablePushFailure,
+ final RowIngestionMeters rowIngestionMeters,
+ final boolean skipBytesInMemoryOverheadCheck,
+ final boolean batchFallback
+ )
+ {
+ objectMapper = new DefaultObjectMapper();
+ objectMapper.registerSubtypes(LinearShardSpec.class);
+
+ final Map<String, Object> parserMap = objectMapper.convertValue(
+ new MapInputRowParser(
+ new JSONParseSpec(
+ new TimestampSpec("ts", "auto", null),
+ new DimensionsSpec(null, null, null),
+ null,
+ null,
+ null
+ )
+ ),
+ Map.class
+ );
+ schema = new DataSchema(
+ DATASOURCE,
+ parserMap,
+ new AggregatorFactory[]{
+ new CountAggregatorFactory("count"),
+ new LongSumAggregatorFactory("met", "met")
+ },
+ new UniformGranularitySpec(Granularities.MINUTE, Granularities.NONE, null),
+ null,
+ objectMapper
+ );
+ tuningConfig = new IndexTuningConfig(
+ null,
+ 2,
+ null,
+ maxRowsInMemory,
+ maxSizeInBytes == 0L ? getDefaultMaxBytesInMemory() : maxSizeInBytes,
+ skipBytesInMemoryOverheadCheck,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance(),
+ true,
+ null,
+ null,
+ null,
+ null
+ ).withBasePersistDirectory(basePersistDirectory != null ? basePersistDirectory : createNewBasePersistDirectory());
+
+ metrics = new FireDepartmentMetrics();
+
+ IndexIO indexIO = new IndexIO(
+ objectMapper,
+ new ColumnConfig()
+ {
+ @Override
+ public int columnCacheSizeBytes()
+ {
+ return 0;
+ }
+ }
+ );
+ IndexMerger indexMerger = new IndexMergerV9(
+ objectMapper,
+ indexIO,
+ OffHeapMemorySegmentWriteOutMediumFactory.instance()
+ );
+
+ emitter = new ServiceEmitter(
+ "test",
+ "test",
+ new NoopEmitter()
+ );
+ emitter.start();
+ EmittingLogger.registerEmitter(emitter);
+ dataSegmentPusher = new DataSegmentPusher()
+ {
+ private boolean mustFail = true;
+
+ @Deprecated
+ @Override
+ public String getPathForHadoop(String dataSource)
+ {
+ return getPathForHadoop();
+ }
+
+ @Override
+ public String getPathForHadoop()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DataSegment push(File file, DataSegment segment, boolean useUniquePath) throws IOException
+ {
+ if (enablePushFailure && mustFail) {
+ mustFail = false;
+ throw new IOException("Push failure test");
+ } else if (enablePushFailure) {
+ mustFail = true;
+ }
+ pushedSegments.add(segment);
+ return segment;
+ }
+
+ @Override
+ public Map<String, Object> makeLoadSpec(URI uri)
+ {
+ throw new UnsupportedOperationException();
+ }
+ };
+ appenderator = Appenderators.createOffline(
+ schema.getDataSource(),
+ schema,
+ tuningConfig,
+ metrics,
+ dataSegmentPusher,
+ objectMapper,
+ indexIO,
+ indexMerger,
+ rowIngestionMeters,
+ new ParseExceptionHandler(rowIngestionMeters, false, Integer.MAX_VALUE, 0),
+ batchFallback
+ );
+ }
+
+ private long getDefaultMaxBytesInMemory()
+ {
+ return (Runtime.getRuntime().totalMemory()) / 3;
+ }
+
+ public DataSchema getSchema()
+ {
+ return schema;
+ }
+
+ public AppenderatorConfig getTuningConfig()
+ {
+ return tuningConfig;
+ }
+
+ public FireDepartmentMetrics getMetrics()
+ {
+ return metrics;
+ }
+
+ public ObjectMapper getObjectMapper()
+ {
+ return objectMapper;
+ }
+
+ public Appenderator getAppenderator()
+ {
+ return appenderator;
+ }
+
+ public List<DataSegment> getPushedSegments()
+ {
+ return pushedSegments;
+ }
+
+ @Override
+ public void close() throws Exception
+ {
+ appenderator.close();
+ emitter.close();
+ FileUtils.deleteDirectory(tuningConfig.getBasePersistDirectory());
+ }
+
+ private static File createNewBasePersistDirectory()
+ {
+ return FileUtils.createTempDir("druid-batch-persist");
+ }
+
+
+ // copied from druid-indexing as is for testing since it is not accessible from server module,
+ // we could simplify since not all its functionality is being used
+ // but leaving as is, it could be useful later
+ private static class IndexTuningConfig implements AppenderatorConfig
Review comment:
Cleaned up but most of the code is setting defaults (when nulls are passed to the constructor) that are necessary for appenderator to function.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658477956
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java
##########
@@ -172,7 +172,7 @@ SegmentWithState getAppendingSegment()
/**
* Allocated segments for a sequence
*/
- static class SegmentsForSequence
+ public static class SegmentsForSequence
Review comment:
It is needed in `BatchAppenderatorDriver` which is in a different module
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r664797015
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called). It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+ /* Reference to directory that holds the persisted data */
+ File persistedFileDir;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ public void setPersistedFileDir(File persistedFileDir)
+ {
+ this.persistedFileDir = persistedFileDir;
+ }
+
+ public File getPersistedFileDir()
+ {
+ return persistedFileDir;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ return null;
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, unused -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrant();
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndRemoveSinks();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, false);
+ }
+
+ @Override
+ /**
+ * Returns all active segments regardless whether they are in memory or persisted
+ */
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinksMetadata.keySet());
+ }
+
+ @VisibleForTesting
+ public List<SegmentIdWithShardSpec> getInMemorySegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed());
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear()
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData)
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ // Drop everything.
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ removeSink(entry.getKey(), entry.getValue(), removeOnDiskData);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ removeSink(identifier, sink, true);
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ if (committer != null) {
+ throw new ISE("committer must be null for BatchAppenderator");
+ }
+ persistAllAndRemoveSinks();
+ return Futures.immediateFuture(null);
+ }
+
+ /**
+ * Persist all sinks & their hydrants, keep their metadata, and then remove them completely from
+ * memory (to be resurrected right before merge & push)
+ */
+ private void persistAllAndRemoveSinks()
+ {
+
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ int totalHydrantsCount = 0;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ // Since everytime we persist we also get rid of the in-memory references to sinks & hydrants
+ // the invariant of exactly one, always swappable, sink with exactly one unpersisted hydrant must hold
+ int totalHydrantsForSink = hydrants.size();
+ if (totalHydrantsForSink != 1) {
+ throw new ISE("There should be only onw hydrant for identifier[%s] but there are[%s]",
Review comment:
Done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r655795344
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.client.cache.Cache;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ private final Cache cache;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist. For now, {@link SinkMetadata} only
+ * contains a single memeber {@link SinkMetadata#numRowsInSegment} but we can add more in the future as needed
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ Cache cache,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.cache = cache;
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ //objectMapper.writeValue(descriptorFile, segment);
Review comment:
Not required, removed.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658481702
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
Review comment:
Cleaned up
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658481853
##########
File path: server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderator.java
##########
@@ -0,0 +1,1335 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.segment.realtime.appenderator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.lang.mutable.MutableInt;
+import org.apache.druid.data.input.Committer;
+import org.apache.druid.data.input.InputRow;
+import org.apache.druid.java.util.common.FileUtils;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.ISE;
+import org.apache.druid.java.util.common.Pair;
+import org.apache.druid.java.util.common.RE;
+import org.apache.druid.java.util.common.RetryUtils;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.query.Query;
+import org.apache.druid.query.QueryRunner;
+import org.apache.druid.query.SegmentDescriptor;
+import org.apache.druid.segment.IndexIO;
+import org.apache.druid.segment.IndexMerger;
+import org.apache.druid.segment.QueryableIndex;
+import org.apache.druid.segment.QueryableIndexSegment;
+import org.apache.druid.segment.ReferenceCountingSegment;
+import org.apache.druid.segment.incremental.IncrementalIndexAddResult;
+import org.apache.druid.segment.incremental.IndexSizeExceededException;
+import org.apache.druid.segment.incremental.ParseExceptionHandler;
+import org.apache.druid.segment.incremental.RowIngestionMeters;
+import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.loading.DataSegmentPusher;
+import org.apache.druid.segment.realtime.FireDepartmentMetrics;
+import org.apache.druid.segment.realtime.FireHydrant;
+import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.server.coordination.DataSegmentAnnouncer;
+import org.apache.druid.timeline.DataSegment;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+public class BatchAppenderator implements Appenderator
+{
+ public static final int ROUGH_OVERHEAD_PER_SINK = 5000;
+ // Rough estimate of memory footprint of empty FireHydrant based on actual heap dumps
+ public static final int ROUGH_OVERHEAD_PER_HYDRANT = 1000;
+
+ private static final EmittingLogger log = new EmittingLogger(BatchAppenderator.class);
+ private static final int WARN_DELAY = 1000;
+ private static final String IDENTIFIER_FILE_NAME = "identifier.json";
+
+ private final String myId;
+ private final DataSchema schema;
+ private final AppenderatorConfig tuningConfig;
+ private final FireDepartmentMetrics metrics;
+ private final DataSegmentPusher dataSegmentPusher;
+ private final ObjectMapper objectMapper;
+ private final IndexIO indexIO;
+ private final IndexMerger indexMerger;
+ /**
+ * This map needs to be concurrent because it's accessed and mutated from multiple threads: both the thread from where
+ * this Appenderator is used (and methods like {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)} are
+ * called) and from {@link #persistExecutor}. It could also be accessed (but not mutated) potentially in the context
+ * of any thread from {@link #drop}.
+ */
+ private final ConcurrentMap<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+ private final long maxBytesTuningConfig;
+ private final boolean skipBytesInMemoryOverheadCheck;
+
+ /**
+ * The following sinks metadata map and associated class are the way to retain metadata now that sinks
+ * are being completely removed from memory after each incremental persist.
+ */
+ private final ConcurrentHashMap<SegmentIdWithShardSpec, SinkMetadata> sinksMetadata = new ConcurrentHashMap<>();
+
+ /**
+ * This class is used for information that needs to be kept related to Sinks as
+ * they are persisted and removed from memory at every incremental persist.
+ * The information is used for sanity checks and as information required
+ * for functionality, depending in the field that is used. More info about the
+ * fields is annotated as comments in the class
+ */
+ private static class SinkMetadata
+ {
+ /** This is used to maintain the rows in the sink accross persists of the sink
+ * used for functionality (i.e. to detect whether an incremental push
+ * is needed {@link AppenderatorDriverAddResult#isPushRequired(Integer, Long)}
+ **/
+ private int numRowsInSegment;
+ /** For sanity check as well as functionality: to make sure that all hydrants for a sink are restored from disk at
+ * push time and also to remember the fire hydrant "count" when persisting it.
+ */
+ private int numHydrants;
+
+ public SinkMetadata()
+ {
+ this(0, 0);
+ }
+
+ public SinkMetadata(int numRowsInSegment, int numHydrants)
+ {
+ this.numRowsInSegment = numRowsInSegment;
+ this.numHydrants = numHydrants;
+ }
+
+ public void addRows(int num)
+ {
+ numRowsInSegment += num;
+ }
+
+ public void addHydrants(int num)
+ {
+ numHydrants += num;
+ }
+
+ public int getNumRowsInSegment()
+ {
+ return numRowsInSegment;
+ }
+
+ public int getNumHydrants()
+ {
+ return numHydrants;
+ }
+
+ }
+
+ // This variable updated in add(), persist(), and drop()
+ private final AtomicInteger rowsCurrentlyInMemory = new AtomicInteger();
+ private final AtomicInteger totalRows = new AtomicInteger();
+ private final AtomicLong bytesCurrentlyInMemory = new AtomicLong();
+ private final RowIngestionMeters rowIngestionMeters;
+ private final ParseExceptionHandler parseExceptionHandler;
+
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ private volatile ListeningExecutorService persistExecutor = null;
+ private volatile ListeningExecutorService pushExecutor = null;
+ // use intermediate executor so that deadlock conditions can be prevented
+ // where persist and push Executor try to put tasks in each other queues
+ // thus creating circular dependency
+ private volatile ListeningExecutorService intermediateTempExecutor = null;
+ private volatile FileLock basePersistDirLock = null;
+ private volatile FileChannel basePersistDirLockChannel = null;
+
+ private volatile Throwable persistError;
+
+ /**
+ * This constructor allows the caller to provide its own SinkQuerySegmentWalker.
+ * <p>
+ * The sinkTimeline is set to the sink timeline of the provided SinkQuerySegmentWalker.
+ * If the SinkQuerySegmentWalker is null, a new sink timeline is initialized.
+ * <p>
+ * It is used by UnifiedIndexerAppenderatorsManager which allows queries on data associated with multiple
+ * Appenderators.
+ */
+ BatchAppenderator(
+ String id,
+ DataSchema schema,
+ AppenderatorConfig tuningConfig,
+ FireDepartmentMetrics metrics,
+ DataSegmentPusher dataSegmentPusher,
+ ObjectMapper objectMapper,
+ DataSegmentAnnouncer segmentAnnouncer,
+ @Nullable SinkQuerySegmentWalker sinkQuerySegmentWalker,
+ IndexIO indexIO,
+ IndexMerger indexMerger,
+ RowIngestionMeters rowIngestionMeters,
+ ParseExceptionHandler parseExceptionHandler
+ )
+ {
+ Preconditions.checkArgument(
+ sinkQuerySegmentWalker == null,
+ "Batch appenderator does not use a versioned timeline"
+ );
+
+ this.myId = id;
+ this.schema = Preconditions.checkNotNull(schema, "schema");
+ this.tuningConfig = Preconditions.checkNotNull(tuningConfig, "tuningConfig");
+ this.metrics = Preconditions.checkNotNull(metrics, "metrics");
+ this.dataSegmentPusher = Preconditions.checkNotNull(dataSegmentPusher, "dataSegmentPusher");
+ this.objectMapper = Preconditions.checkNotNull(objectMapper, "objectMapper");
+ this.indexIO = Preconditions.checkNotNull(indexIO, "indexIO");
+ this.indexMerger = Preconditions.checkNotNull(indexMerger, "indexMerger");
+ this.rowIngestionMeters = Preconditions.checkNotNull(rowIngestionMeters, "rowIngestionMeters");
+ this.parseExceptionHandler = Preconditions.checkNotNull(parseExceptionHandler, "parseExceptionHandler");
+
+ maxBytesTuningConfig = tuningConfig.getMaxBytesInMemoryOrDefault();
+ skipBytesInMemoryOverheadCheck = tuningConfig.isSkipBytesInMemoryOverheadCheck();
+ }
+
+ @Override
+ public String getId()
+ {
+ return myId;
+ }
+
+ @Override
+ public String getDataSource()
+ {
+ return schema.getDataSource();
+ }
+
+ @Override
+ public Object startJob()
+ {
+ tuningConfig.getBasePersistDirectory().mkdirs();
+ lockBasePersistDirectory();
+ initializeExecutors();
+ return null;
+ }
+
+ private void throwPersistErrorIfExists()
+ {
+ if (persistError != null) {
+ throw new RE(persistError, "Error while persisting");
+ }
+ }
+
+ @Override
+ public AppenderatorAddResult add(
+ final SegmentIdWithShardSpec identifier,
+ final InputRow row,
+ @Nullable final Supplier<Committer> committerSupplier,
+ final boolean allowIncrementalPersists
+ ) throws IndexSizeExceededException, SegmentNotWritableException
+ {
+
+ throwPersistErrorIfExists();
+
+ Preconditions.checkArgument(
+ committerSupplier == null,
+ "Batch appenderator does not need a committer!"
+ );
+
+ Preconditions.checkArgument(
+ allowIncrementalPersists,
+ "Batch appenderator should always allow incremental persists!"
+ );
+
+ if (!identifier.getDataSource().equals(schema.getDataSource())) {
+ throw new IAE(
+ "Expected dataSource[%s] but was asked to insert row for dataSource[%s]?!",
+ schema.getDataSource(),
+ identifier.getDataSource()
+ );
+ }
+
+ final Sink sink = getOrCreateSink(identifier);
+ metrics.reportMessageMaxTimestamp(row.getTimestampFromEpoch());
+ final int sinkRowsInMemoryBeforeAdd = sink.getNumRowsInMemory();
+ final int sinkRowsInMemoryAfterAdd;
+ final long bytesInMemoryBeforeAdd = sink.getBytesInMemory();
+ final long bytesInMemoryAfterAdd;
+ final IncrementalIndexAddResult addResult;
+
+ try {
+ addResult = sink.add(row, false); // allow incrememtal persis is always true for batch
+ sinkRowsInMemoryAfterAdd = addResult.getRowCount();
+ bytesInMemoryAfterAdd = addResult.getBytesInMemory();
+ }
+ catch (IndexSizeExceededException e) {
+ // Uh oh, we can't do anything about this! We can't persist (commit metadata would be out of sync) and we
+ // can't add the row (it just failed). This should never actually happen, though, because we check
+ // sink.canAddRow after returning from add.
+ log.error(e, "Sink for segment[%s] was unexpectedly full!", identifier);
+ throw e;
+ }
+
+ if (sinkRowsInMemoryAfterAdd < 0) {
+ throw new SegmentNotWritableException("Attempt to add row to swapped-out sink for segment[%s].", identifier);
+ }
+
+ if (addResult.isRowAdded()) {
+ rowIngestionMeters.incrementProcessed();
+ } else if (addResult.hasParseException()) {
+ parseExceptionHandler.handle(addResult.getParseException());
+ }
+
+ final int numAddedRows = sinkRowsInMemoryAfterAdd - sinkRowsInMemoryBeforeAdd;
+ rowsCurrentlyInMemory.addAndGet(numAddedRows);
+ bytesCurrentlyInMemory.addAndGet(bytesInMemoryAfterAdd - bytesInMemoryBeforeAdd);
+ totalRows.addAndGet(numAddedRows);
+ sinksMetadata.computeIfAbsent(identifier, Void -> new SinkMetadata()).addRows(numAddedRows);
+
+ boolean isPersistRequired = false;
+ boolean persist = false;
+ List<String> persistReasons = new ArrayList<>();
+
+ if (!sink.canAppendRow()) {
+ persist = true;
+ persistReasons.add("No more rows can be appended to sink");
+ }
+ if (rowsCurrentlyInMemory.get() >= tuningConfig.getMaxRowsInMemory()) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "rowsCurrentlyInMemory[%d] is greater than maxRowsInMemory[%d]",
+ rowsCurrentlyInMemory.get(),
+ tuningConfig.getMaxRowsInMemory()
+ ));
+ }
+ if (bytesCurrentlyInMemory.get() >= maxBytesTuningConfig) {
+ persist = true;
+ persistReasons.add(StringUtils.format(
+ "bytesCurrentlyInMemory[%d] is greater than maxBytesInMemory[%d]",
+ bytesCurrentlyInMemory.get(),
+ maxBytesTuningConfig
+ ));
+ }
+ if (persist) {
+ // persistAll clears rowsCurrentlyInMemory, no need to update it.
+ log.info("Incremental persist to disk because %s.", String.join(",", persistReasons));
+
+ long bytesToBePersisted = 0L;
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final Sink sinkEntry = entry.getValue();
+ if (sinkEntry != null) {
+ bytesToBePersisted += sinkEntry.getBytesInMemory();
+ if (sinkEntry.swappable()) {
+ // Code for batch no longer memory maps hydrants but they still take memory...
+ int memoryStillInUse = calculateMemoryUsedByHydrants(sink.getCurrHydrant());
+ bytesCurrentlyInMemory.addAndGet(memoryStillInUse);
+ }
+ }
+ }
+
+ if (!skipBytesInMemoryOverheadCheck
+ && bytesCurrentlyInMemory.get() - bytesToBePersisted > maxBytesTuningConfig) {
+ // We are still over maxBytesTuningConfig even after persisting.
+ // This means that we ran out of all available memory to ingest (due to overheads created as part of ingestion)
+ final String alertMessage = StringUtils.format(
+ "Task has exceeded safe estimated heap usage limits, failing "
+ + "(numSinks: [%d] numHydrantsAcrossAllSinks: [%d] totalRows: [%d])"
+ + "(bytesCurrentlyInMemory: [%d] - bytesToBePersisted: [%d] > maxBytesTuningConfig: [%d])",
+ sinks.size(),
+ sinks.values().stream().mapToInt(Iterables::size).sum(),
+ getTotalRowCount(),
+ bytesCurrentlyInMemory.get(),
+ bytesToBePersisted,
+ maxBytesTuningConfig
+ );
+ final String errorMessage = StringUtils.format(
+ "%s.\nThis can occur when the overhead from too many intermediary segment persists becomes to "
+ + "great to have enough space to process additional input rows. This check, along with metering the overhead "
+ + "of these objects to factor into the 'maxBytesInMemory' computation, can be disabled by setting "
+ + "'skipBytesInMemoryOverheadCheck' to 'true' (note that doing so might allow the task to naturally encounter "
+ + "a 'java.lang.OutOfMemoryError'). Alternatively, 'maxBytesInMemory' can be increased which will cause an "
+ + "increase in heap footprint, but will allow for more intermediary segment persists to occur before "
+ + "reaching this condition.",
+ alertMessage
+ );
+ log.makeAlert(alertMessage)
+ .addData("dataSource", schema.getDataSource())
+ .emit();
+ throw new RuntimeException(errorMessage);
+ }
+
+ persistAllAndClear();
+
+ }
+ return new AppenderatorAddResult(identifier, sinksMetadata.get(identifier).numRowsInSegment, isPersistRequired);
+ }
+
+ @Override
+ public List<SegmentIdWithShardSpec> getSegments()
+ {
+ return ImmutableList.copyOf(sinks.keySet());
+ }
+
+ @Override
+ public int getRowCount(final SegmentIdWithShardSpec identifier)
+ {
+ return sinksMetadata.get(identifier).getNumRowsInSegment();
+ }
+
+ @Override
+ public int getTotalRowCount()
+ {
+ return totalRows.get();
+ }
+
+ @VisibleForTesting
+ public int getRowsInMemory()
+ {
+ return rowsCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesCurrentlyInMemory()
+ {
+ return bytesCurrentlyInMemory.get();
+ }
+
+ @VisibleForTesting
+ public long getBytesInMemory(SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+
+ if (sink == null) {
+ return 0L; // sinks are removed after a persist
+ } else {
+ return sink.getBytesInMemory();
+ }
+ }
+
+ private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
+ {
+ Sink retVal = sinks.get(identifier);
+
+ if (retVal == null) {
+ retVal = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null
+ );
+ bytesCurrentlyInMemory.addAndGet(calculateSinkMemoryInUsed(retVal));
+
+ sinks.put(identifier, retVal);
+ metrics.setSinkCount(sinks.size());
+ }
+
+ return retVal;
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, final Iterable<Interval> intervals)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs)
+ {
+ throw new UnsupportedOperationException("No query runner for batch appenderator");
+ }
+
+ @Override
+ public void clear() throws InterruptedException
+ {
+ clear(true);
+ }
+
+ private void clear(boolean removeOnDiskData) throws InterruptedException
+ {
+ // Drop commit metadata, then abandon all segments.
+ log.info("Clearing all sinks & hydrants, removing data on disk: [%s]", removeOnDiskData);
+ try {
+ throwPersistErrorIfExists();
+ // Drop everything.
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), removeOnDiskData));
+ }
+ // Await dropping.
+ Futures.allAsList(futures).get();
+ }
+ catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
+ {
+ final Sink sink = sinks.get(identifier);
+ SinkMetadata sm = sinksMetadata.remove(identifier);
+ if (sm != null) {
+ int originalTotalRows = getTotalRowCount();
+ int rowsToDrop = sm.getNumRowsInSegment();
+ int totalRowsAfter = originalTotalRows - rowsToDrop;
+ if (totalRowsAfter < 0) {
+ log.warn("Total rows[%d] after dropping segment[%s] rows [%d]", totalRowsAfter, identifier, rowsToDrop);
+ }
+ totalRows.set(Math.max(totalRowsAfter, 0));
+ }
+ if (sink != null) {
+ return removeSink(identifier, sink, true);
+ } else {
+ return Futures.immediateFuture(null);
+ }
+ }
+
+ private SegmentsAndCommitMetadata persistAllAndClear()
+ {
+ final ListenableFuture<Object> toPersist = Futures.transform(
+ persistAll(null),
+ (Function<Object, Object>) future -> future
+ );
+
+ // make sure sinks are cleared before push is called
+ final SegmentsAndCommitMetadata commitMetadata;
+ try {
+ commitMetadata = (SegmentsAndCommitMetadata) toPersist.get();
+ clear(false);
+ return commitMetadata;
+ }
+ catch (Throwable t) {
+ persistError = t;
+ }
+ return null;
+ }
+
+ @Override
+ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
+ {
+ throwPersistErrorIfExists();
+ final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = new ArrayList<>();
+ int numPersistedRows = 0;
+ long bytesPersisted = 0L;
+ MutableInt totalHydrantsCount = new MutableInt();
+ MutableInt totalHydrantsPersistedAcrossSinks = new MutableInt();
+ SegmentIdWithShardSpec startIdentifier = null;
+ final long totalSinks = sinks.size();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ final SegmentIdWithShardSpec identifier = entry.getKey();
+ final Sink sink = entry.getValue();
+ if (sink == null) {
+ throw new ISE("No sink for identifier: %s", identifier);
+ }
+
+ final List<FireHydrant> hydrants = Lists.newArrayList(sink);
+ totalHydrantsCount.add(hydrants.size());
+ numPersistedRows += sink.getNumRowsInMemory();
+ bytesPersisted += sink.getBytesInMemory();
+
+ final int limit = sink.isWritable() ? hydrants.size() - 1 : hydrants.size();
+
+ // gather hydrants that have not been persisted:
+ for (FireHydrant hydrant : hydrants.subList(0, limit)) {
+ if (!hydrant.hasSwapped()) {
+ log.debug("Hydrant[%s] hasn't persisted yet, persisting. Segment[%s]", hydrant, identifier);
+ indexesToPersist.add(Pair.of(hydrant, identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+ }
+
+ if (sink.swappable()) {
+ // It is swappable. Get the old one to persist it and create a new one:
+ indexesToPersist.add(Pair.of(sink.swap(), identifier));
+ totalHydrantsPersistedAcrossSinks.add(1);
+ }
+
+ }
+ log.debug("Submitting persist runnable for dataSource[%s]", schema.getDataSource());
+
+ if (indexesToPersist.isEmpty()) {
+ log.info("No indexes will be peristed");
+ }
+ final Stopwatch runExecStopwatch = Stopwatch.createStarted();
+ final Stopwatch persistStopwatch = Stopwatch.createStarted();
+ AtomicLong totalPersistedRows = new AtomicLong(numPersistedRows);
+ final ListenableFuture<Object> future = persistExecutor.submit(
+ new Callable<Object>()
+ {
+ @Override
+ public Object call()
+ {
+ try {
+ for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
+ metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
+ }
+
+ log.info(
+ "Persisted in-memory data for segments: %s",
+ indexesToPersist.stream()
+ .map(itp -> itp.rhs.asSegmentId().toString())
+ .distinct()
+ .collect(Collectors.joining(", "))
+ );
+ log.info(
+ "Persisted stats: processed rows: [%d], persisted rows[%d], sinks: [%d], total fireHydrants (across sinks): [%d], persisted fireHydrants (across sinks): [%d]",
+ rowIngestionMeters.getProcessed(),
+ totalPersistedRows.get(),
+ totalSinks,
+ totalHydrantsCount.longValue(),
+ totalHydrantsPersistedAcrossSinks.longValue()
+ );
+
+ // return null if committer is null
+ return null;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedPersists();
+ throw e;
+ }
+ finally {
+ metrics.incrementNumPersists();
+ metrics.incrementPersistTimeMillis(persistStopwatch.elapsed(TimeUnit.MILLISECONDS));
+ persistStopwatch.stop();
+ }
+ }
+ }
+ );
+
+ final long startDelay = runExecStopwatch.elapsed(TimeUnit.MILLISECONDS);
+ metrics.incrementPersistBackPressureMillis(startDelay);
+ if (startDelay > WARN_DELAY) {
+ log.warn("Ingestion was throttled for [%,d] millis because persists were pending.", startDelay);
+ }
+ runExecStopwatch.stop();
+
+ // NB: The rows are still in memory until they're done persisting, but we only count rows in active indexes.
+ rowsCurrentlyInMemory.addAndGet(-numPersistedRows);
+ bytesCurrentlyInMemory.addAndGet(-bytesPersisted);
+
+ log.info("Persisted rows[%,d] and bytes[%,d]", numPersistedRows, bytesPersisted);
+
+ return future;
+ }
+
+ @Override
+ public ListenableFuture<SegmentsAndCommitMetadata> push(
+ final Collection<SegmentIdWithShardSpec> identifiers,
+ @Nullable final Committer committer,
+ final boolean useUniquePath
+ )
+ {
+
+ if (committer != null) {
+ throw new ISE("There should be no committer for batch ingestion");
+ }
+
+ // Any sinks not persisted so far will be persisted before push:
+ final SegmentsAndCommitMetadata commitMetadata = persistAllAndClear();
+
+ final ListenableFuture<SegmentsAndCommitMetadata> pushFuture = pushExecutor.submit(
+ new Callable<SegmentsAndCommitMetadata>()
+ {
+ @Override
+ public SegmentsAndCommitMetadata call()
+ {
+ log.info("Preparing to push...");
+
+ final List<DataSegment> dataSegments = new ArrayList<>();
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ Pair<SegmentIdWithShardSpec, Sink> identifiersAndSinks = getIdentifierAndSinkForPersistedFile(identifier);
+ final DataSegment dataSegment = mergeAndPush(
+ identifiersAndSinks.lhs,
+ identifiersAndSinks.rhs,
+ useUniquePath
+ );
+ if (dataSegment != null) {
+ dataSegments.add(dataSegment);
+ } else {
+ log.warn("mergeAndPush[%s] returned null, skipping.", identifiersAndSinks.lhs);
+ }
+ }
+
+ log.info("Push complete...");
+
+ return new SegmentsAndCommitMetadata(dataSegments, commitMetadata);
+ }
+ });
+
+ return pushFuture;
+ }
+
+ /**
+ * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished.
+ * This is useful if we're going to do something that would otherwise potentially break currently in-progress
+ * pushes.
+ */
+ private ListenableFuture<?> pushBarrier()
+ {
+ return intermediateTempExecutor.submit(
+ (Runnable) () -> pushExecutor.submit(() -> {
+ })
+ );
+ }
+
+ /**
+ * Merge segment, push to deep storage. Should only be used on segments that have been fully persisted. Must only
+ * be run in the single-threaded pushExecutor.
+ *
+ * @param identifier sink identifier
+ * @param sink sink to push
+ * @param useUniquePath true if the segment should be written to a path with a unique identifier
+ * @return segment descriptor, or null if the sink is no longer valid
+ */
+ @Nullable
+ private DataSegment mergeAndPush(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean useUniquePath
+ )
+ {
+
+ // Use a descriptor file to indicate that pushing has completed.
+ final File persistDir = computePersistDir(identifier);
+ final File mergedTarget = new File(persistDir, "merged");
+ final File descriptorFile = computeDescriptorFile(identifier);
+
+ // Sanity checks
+ if (sink.isWritable()) {
+ throw new ISE("Expected sink to be no longer writable before mergeAndPush for segment[%s].", identifier);
+ }
+
+ int numHydrants = 0;
+ for (FireHydrant hydrant : sink) {
+ synchronized (hydrant) {
+ if (!hydrant.hasSwapped()) {
+ throw new ISE("Expected sink to be fully persisted before mergeAndPush for segment[%s].", identifier);
+ }
+ }
+ numHydrants++;
+ }
+
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ if (sm == null) {
+ log.warn("Sink metadata not found just before merge for identifier [%s]", identifier);
+ } else if (numHydrants != sinksMetadata.get(identifier).getNumHydrants()) {
+ throw new ISE("Number of restored hydrants[%d] for identifier[%s] does not match expected value[%d]",
+ numHydrants, identifier, sinksMetadata.get(identifier).getNumHydrants());
+ }
+
+ try {
+ if (descriptorFile.exists()) {
+ // Already pushed.
+
+ if (useUniquePath) {
+ // Don't reuse the descriptor, because the caller asked for a unique path. Leave the old one as-is, since
+ // it might serve some unknown purpose.
+ log.debug(
+ "Segment[%s] already pushed, but we want a unique path, so will push again with a new path.",
+ identifier
+ );
+ } else {
+ log.info("Segment[%s] already pushed, skipping.", identifier);
+ return objectMapper.readValue(descriptorFile, DataSegment.class);
+ }
+ }
+
+ removeDirectory(mergedTarget);
+
+ if (mergedTarget.exists()) {
+ throw new ISE("Merged target[%s] exists after removing?!", mergedTarget);
+ }
+
+ final File mergedFile;
+ final long mergeFinishTime;
+ final long startTime = System.nanoTime();
+ List<QueryableIndex> indexes = new ArrayList<>();
+ Closer closer = Closer.create();
+ try {
+ for (FireHydrant fireHydrant : sink) {
+ Pair<ReferenceCountingSegment, Closeable> segmentAndCloseable = fireHydrant.getAndIncrementSegment();
+ final QueryableIndex queryableIndex = segmentAndCloseable.lhs.asQueryableIndex();
+ log.debug("Segment[%s] adding hydrant[%s]", identifier, fireHydrant);
+ indexes.add(queryableIndex);
+ closer.register(segmentAndCloseable.rhs);
+ }
+
+ mergedFile = indexMerger.mergeQueryableIndex(
+ indexes,
+ schema.getGranularitySpec().isRollup(),
+ schema.getAggregators(),
+ schema.getDimensionsSpec(),
+ mergedTarget,
+ tuningConfig.getIndexSpec(),
+ tuningConfig.getSegmentWriteOutMediumFactory(),
+ tuningConfig.getMaxColumnsToMerge()
+ );
+
+ mergeFinishTime = System.nanoTime();
+
+ log.debug("Segment[%s] built in %,dms.", identifier, (mergeFinishTime - startTime) / 1000000);
+ }
+ catch (Throwable t) {
+ throw closer.rethrow(t);
+ }
+ finally {
+ closer.close();
+ }
+
+ // Retry pushing segments because uploading to deep storage might fail especially for cloud storage types
+ final DataSegment segment = RetryUtils.retry(
+ // The appenderator is currently being used for the local indexing task and the Kafka indexing task. For the
+ // Kafka indexing task, pushers must use unique file paths in deep storage in order to maintain exactly-once
+ // semantics.
+ () -> dataSegmentPusher.push(
+ mergedFile,
+ sink.getSegment()
+ .withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(
+ indexes,
+ schema.getDimensionsSpec()
+ )),
+ useUniquePath
+ ),
+ exception -> exception instanceof Exception,
+ 5
+ );
+
+ // Drop the queryable indexes behind the hydrants... they are not needed anymore and their
+ // mapped file references
+ // can generate OOMs during merge if enough of them are held back...
+ // agfixme: Since we cannot keep sinks due to memory growth then we have to add the sink metadata table and keep it up to date
+ //sinks.put(identifier,sink);
+ for (FireHydrant fireHydrant : sink) {
+ fireHydrant.swapSegment(null);
+ }
+
+ // cleanup, sink no longer needed
+ removeDirectory(computePersistDir(identifier));
+
+ final long pushFinishTime = System.nanoTime();
+
+ log.info(
+ "Segment[%s] of %,d bytes "
+ + "built from %d incremental persist(s) in %,dms; "
+ + "pushed to deep storage in %,dms. "
+ + "Load spec is: %s",
+ identifier,
+ segment.getSize(),
+ indexes.size(),
+ (mergeFinishTime - startTime) / 1000000,
+ (pushFinishTime - mergeFinishTime) / 1000000,
+ objectMapper.writeValueAsString(segment.getLoadSpec())
+ );
+
+ return segment;
+ }
+ catch (Exception e) {
+ metrics.incrementFailedHandoffs();
+ log.warn(e, "Failed to push merged index for segment[%s].", identifier);
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void close()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping close() call.");
+ return;
+ }
+
+ log.debug("Shutting down...");
+
+ final List<ListenableFuture<?>> futures = new ArrayList<>();
+ for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
+ futures.add(removeSink(entry.getKey(), entry.getValue(), false));
+ }
+
+ try {
+ Futures.allAsList(futures).get();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn(e, "Interrupted during close()");
+ }
+ catch (ExecutionException e) {
+ log.warn(e, "Unable to abandon existing segments during close()");
+ }
+
+ try {
+ shutdownExecutors();
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ pushExecutor == null || pushExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "pushExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ pushExecutor = null;
+ intermediateTempExecutor = null;
+
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+
+ // Only unlock if executors actually shut down.
+ unlockBasePersistDirectory();
+
+ // cleanup:
+ List<File> persistedIdentifiers = getPersistedidentifierPaths();
+ for (File identifier : persistedIdentifiers) {
+ removeDirectory(identifier);
+ }
+
+ totalRows.set(0);
+ sinksMetadata.clear();
+ }
+
+ /**
+ * Unannounce the segments and wait for outstanding persists to finish.
+ * Do not unlock base persist dir as we are not waiting for push executor to shut down
+ * relying on current JVM to shutdown to not cause any locking problem if the task is restored.
+ * In case when task is restored and current task is still active because of push executor (which it shouldn't be
+ * since push executor starts daemon threads) then the locking should fail and new task should fail to start.
+ * This also means that this method should only be called when task is shutting down.
+ */
+ @Override
+ public void closeNow()
+ {
+ if (!closed.compareAndSet(false, true)) {
+ log.debug("Appenderator already closed, skipping closeNow() call.");
+ return;
+ }
+
+ log.debug("Shutting down immediately...");
+ try {
+ shutdownExecutors();
+ // We don't wait for pushExecutor to be terminated. See Javadoc for more details.
+ Preconditions.checkState(
+ persistExecutor == null || persistExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "persistExecutor not terminated"
+ );
+ Preconditions.checkState(
+ intermediateTempExecutor == null || intermediateTempExecutor.awaitTermination(365, TimeUnit.DAYS),
+ "intermediateTempExecutor not terminated"
+ );
+ persistExecutor = null;
+ intermediateTempExecutor = null;
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new ISE("Failed to shutdown executors during close()");
+ }
+ }
+
+ private void lockBasePersistDirectory()
+ {
+ if (basePersistDirLock == null) {
+ try {
+ basePersistDirLockChannel = FileChannel.open(
+ computeLockFile().toPath(),
+ StandardOpenOption.CREATE,
+ StandardOpenOption.WRITE
+ );
+
+ basePersistDirLock = basePersistDirLockChannel.tryLock();
+ if (basePersistDirLock == null) {
+ throw new ISE("Cannot acquire lock on basePersistDir: %s", computeLockFile());
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void unlockBasePersistDirectory()
+ {
+ try {
+ if (basePersistDirLock != null) {
+ basePersistDirLock.release();
+ basePersistDirLockChannel.close();
+ basePersistDirLock = null;
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void initializeExecutors()
+ {
+ final int maxPendingPersists = tuningConfig.getMaxPendingPersists();
+
+ if (persistExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ persistExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded(
+ "[" + StringUtils.encodeForFormat(myId) + "]-appenderator-persist",
+ maxPendingPersists
+ )
+ );
+ }
+
+ if (pushExecutor == null) {
+ // use a blocking single threaded executor to throttle the firehose when write to disk is slow
+ pushExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-merge", 1)
+ );
+ }
+
+ if (intermediateTempExecutor == null) {
+ // use single threaded executor with SynchronousQueue so that all abandon operations occur sequentially
+ intermediateTempExecutor = MoreExecutors.listeningDecorator(
+ Execs.newBlockingSingleThreaded("[" + StringUtils.encodeForFormat(myId) + "]-appenderator-abandon", 0)
+ );
+ }
+ }
+
+ private void shutdownExecutors()
+ {
+ if (persistExecutor != null) {
+ persistExecutor.shutdownNow();
+ }
+
+ if (pushExecutor != null) {
+ pushExecutor.shutdownNow();
+ }
+
+ if (intermediateTempExecutor != null) {
+ intermediateTempExecutor.shutdownNow();
+ }
+ }
+
+ @VisibleForTesting
+ public List<File> getPersistedidentifierPaths()
+ {
+
+ ArrayList<File> retVal = new ArrayList<>();
+
+ final File baseDir = tuningConfig.getBasePersistDirectory();
+ if (!baseDir.exists()) {
+ return null;
+ }
+
+ final File[] files = baseDir.listFiles();
+ if (files == null) {
+ return null;
+ }
+
+ for (File sinkDir : files) {
+ final File identifierFile = new File(sinkDir, IDENTIFIER_FILE_NAME);
+ if (!identifierFile.isFile()) {
+ // No identifier in this sinkDir; it must not actually be a sink directory. Skip it.
+ continue;
+ }
+ retVal.add(sinkDir);
+ }
+
+ return retVal;
+ }
+
+ Pair<SegmentIdWithShardSpec, Sink> getIdentifierAndSinkForPersistedFile(File identifierPath)
+ {
+
+ try {
+ final SegmentIdWithShardSpec identifier = objectMapper.readValue(
+ new File(identifierPath, "identifier.json"),
+ SegmentIdWithShardSpec.class
+ );
+
+ // To avoid reading and listing of "merged" dir and other special files
+ final File[] sinkFiles = identifierPath.listFiles(
+ (dir, fileName) -> !(Ints.tryParse(fileName) == null)
+ );
+
+ Arrays.sort(
+ sinkFiles,
+ (o1, o2) -> Ints.compare(Integer.parseInt(o1.getName()), Integer.parseInt(o2.getName()))
+ );
+
+ List<FireHydrant> hydrants = new ArrayList<>();
+ for (File hydrantDir : sinkFiles) {
+ final int hydrantNumber = Integer.parseInt(hydrantDir.getName());
+
+ log.debug("Loading previously persisted partial segment at [%s]", hydrantDir);
+ if (hydrantNumber != hydrants.size()) {
+ throw new ISE("Missing hydrant [%,d] in identifier [%s].", hydrants.size(), identifier);
+ }
+
+ hydrants.add(
+ new FireHydrant(
+ new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
+ hydrantNumber
+ )
+ );
+ }
+
+ Sink currSink = new Sink(
+ identifier.getInterval(),
+ schema,
+ identifier.getShardSpec(),
+ identifier.getVersion(),
+ tuningConfig.getAppendableIndexSpec(),
+ tuningConfig.getMaxRowsInMemory(),
+ maxBytesTuningConfig,
+ null,
+ hydrants
+ );
+ currSink.finishWriting(); // this sink is not writable
+ return new Pair<>(identifier, currSink);
+ }
+ catch (IOException e) {
+ log.makeAlert(e, "Problem loading sink[%s] from disk.", schema.getDataSource())
+ .addData("identifier path", identifierPath)
+ .emit();
+ }
+ return null;
+ }
+
+ private ListenableFuture<?> removeSink(
+ final SegmentIdWithShardSpec identifier,
+ final Sink sink,
+ final boolean removeOnDiskData
+ )
+ {
+ // Ensure no future writes will be made to this sink.
+ if (sink.finishWriting()) {
+ // Decrement this sink's rows from the counters. we only count active sinks so that we don't double decrement,
+ // i.e. those that haven't been persisted for *InMemory counters, or pushed to deep storage for the total counter.
+ rowsCurrentlyInMemory.addAndGet(-sink.getNumRowsInMemory());
+ bytesCurrentlyInMemory.addAndGet(-sink.getBytesInMemory());
+ bytesCurrentlyInMemory.addAndGet(-calculateSinkMemoryInUsed(sink));
+ for (FireHydrant hydrant : sink) {
+ // Decrement memory used by all Memory Mapped Hydrant
+ if (!hydrant.equals(sink.getCurrHydrant())) {
+ bytesCurrentlyInMemory.addAndGet(-calculateMemoryUsedByHydrants(hydrant));
+ }
+ }
+ // totalRows are not decremented when removing the sink from memory, sink was just persisted and it
+ // still "lives" but it is in hibernation. It will be revived later just before push.
+ }
+
+ // Wait for any outstanding pushes to finish, then abandon the segment inside the persist thread.
+ return Futures.transform(
+ pushBarrier(),
+ new Function<Object, Void>()
+ {
+ @Nullable
+ @Override
+ public Void apply(@Nullable Object input)
+ {
+ if (!sinks.remove(identifier, sink)) {
+ log.error("Sink for segment[%s] no longer valid, not abandoning.", identifier);
+ return null;
+ }
+
+ metrics.setSinkCount(sinks.size());
+
+ if (removeOnDiskData) {
+ removeDirectory(computePersistDir(identifier));
+ }
+
+ log.info("Removed sink for segment[%s].", identifier);
+
+ return null;
+ }
+ },
+ // use persistExecutor to make sure that all the pending persists completes before
+ // starting to abandon segments
+ persistExecutor
+ );
+ }
+
+ private File computeLockFile()
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), ".lock");
+ }
+
+ private File computePersistDir(SegmentIdWithShardSpec identifier)
+ {
+ return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
+ }
+
+ private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
+ }
+
+ private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
+ {
+ return new File(computePersistDir(identifier), "descriptor.json");
+ }
+
+ private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
+ {
+ final File persistDir = computePersistDir(identifier);
+ org.apache.commons.io.FileUtils.forceMkdir(persistDir);
+
+ objectMapper.writeValue(computeIdentifierFile(identifier), identifier);
+
+ return persistDir;
+ }
+
+ /**
+ * Persists the given hydrant and returns the number of rows persisted. Must only be called in the single-threaded
+ * persistExecutor.
+ *
+ * @param indexToPersist hydrant to persist
+ * @param identifier the segment this hydrant is going to be part of
+ * @return the number of rows persisted
+ */
+ private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
+ {
+ synchronized (indexToPersist) {
+ if (indexToPersist.hasSwapped()) {
+ log.info(
+ "Segment[%s] hydrant[%s] already swapped. Ignoring request to persist.",
+ identifier,
+ indexToPersist
+ );
+ return 0;
+ }
+
+ log.debug("Segment[%s], persisting Hydrant[%s]", identifier, indexToPersist);
+
+ try {
+ final long startTime = System.nanoTime();
+ int numRows = indexToPersist.getIndex().size();
+
+ // since the sink may have been persisted before it may have lost its
+ // hydrant count, we remember that value in the sinks metadata so we have
+ // to pull it from there....
+ SinkMetadata sm = sinksMetadata.get(identifier);
+ final File persistDir = createPersistDirIfNeeded(identifier);
+ indexMerger.persist(
+ indexToPersist.getIndex(),
+ identifier.getInterval(),
+ new File(persistDir, String.valueOf(sm.getNumHydrants())),
+ tuningConfig.getIndexSpecForIntermediatePersists(),
+ tuningConfig.getSegmentWriteOutMediumFactory()
+ );
+
+ log.info(
+ "Persisted in-memory data for segment[%s] spill[%s] to disk in [%,d] ms (%,d rows).",
+ indexToPersist.getSegmentId(),
+ indexToPersist.getCount(),
+ (System.nanoTime() - startTime) / 1000000,
+ numRows
+ );
+
+ indexToPersist.swapSegment(null);
+ // remember hydrant count:
+ sinksMetadata.get(identifier).addHydrants(1);
+
+ return numRows;
+ }
+ catch (IOException e) {
+ log.makeAlert("Incremental persist failed")
+ .addData("segment", identifier.toString())
+ .addData("dataSource", schema.getDataSource())
+ .addData("count", indexToPersist.getCount())
+ .emit();
+
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void removeDirectory(final File target)
+ {
+ if (target.exists()) {
+ try {
+ FileUtils.deleteDirectory(target);
+ log.info("Removed directory [%s]", target);
+ }
+ catch (Exception e) {
+ log.makeAlert(e, "Failed to remove directory[%s]", schema.getDataSource())
+ .addData("file", target)
+ .emit();
+ }
+ }
+ }
+
+ private int calculateMemoryUsedByHydrants(FireHydrant hydrant)
Review comment:
Cleaned up
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org
[GitHub] [druid] loquisgon commented on a change in pull request #11294: Bound memory utilization for dynamic partitioning (i.e. memory growth is constant)
Posted by GitBox <gi...@apache.org>.
loquisgon commented on a change in pull request #11294:
URL: https://github.com/apache/druid/pull/11294#discussion_r658475756
##########
File path: indexing-service/src/test/java/org/apache/druid/indexing/appenderator/BatchAppenderatorTester.java
##########
@@ -163,7 +177,7 @@ public BatchAppenderatorTester(
null,
null,
null
- ).withBasePersistDirectory(createNewBasePersistDirectory());
+ ).withBasePersistDirectory(basePersistDirectory != null ? basePersistDirectory : createNewBasePersistDirectory());
Review comment:
done
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org