You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by ji...@apache.org on 2023/04/20 06:23:50 UTC

[iotdb] branch ISSUE_5792 updated: apply spotless

This is an automated email from the ASF dual-hosted git repository.

jiangtian pushed a commit to branch ISSUE_5792
in repository https://gitbox.apache.org/repos/asf/iotdb.git


The following commit(s) were added to refs/heads/ISSUE_5792 by this push:
     new b7a6ea9708 apply spotless
b7a6ea9708 is described below

commit b7a6ea970812835df236a591f0dd2a74a9425d22
Author: Tian Jiang <jt...@163.com>
AuthorDate: Thu Apr 20 14:26:18 2023 +0800

    apply spotless
---
 client-go                                          |   2 +-
 .../commons/concurrent/dynamic/DynamicThread.java  |   3 +-
 .../concurrent/dynamic/DynamicThreadGroup.java     |  16 ++--
 .../iotdb/db/engine/flush/MemTableFlushTaskV2.java | 104 ++++++++++++---------
 .../iotdb/db/engine/flush/tasks/DeviceIOTask.java  |   3 +-
 .../db/engine/flush/tasks/EncodeSeriesTask.java    |   9 +-
 .../iotdb/db/engine/flush/tasks/FlushContext.java  |   8 +-
 .../db/engine/flush/tasks/FlushDeviceContext.java  |   6 +-
 .../db/engine/flush/tasks/SortSeriesTask.java      |   2 +-
 .../apache/iotdb/db/engine/flush/tasks/Task.java   |   1 +
 10 files changed, 91 insertions(+), 63 deletions(-)

diff --git a/client-go b/client-go
index a05323c73a..84b8d45829 160000
--- a/client-go
+++ b/client-go
@@ -1 +1 @@
-Subproject commit a05323c73a3d615efde25d4d3287fcee32ec1292
+Subproject commit 84b8d45829d846440a3246400e7bc5e39587dcb5
diff --git a/node-commons/src/main/java/org/apache/iotdb/commons/concurrent/dynamic/DynamicThread.java b/node-commons/src/main/java/org/apache/iotdb/commons/concurrent/dynamic/DynamicThread.java
index 1bbb6d16c7..5255f2d531 100644
--- a/node-commons/src/main/java/org/apache/iotdb/commons/concurrent/dynamic/DynamicThread.java
+++ b/node-commons/src/main/java/org/apache/iotdb/commons/concurrent/dynamic/DynamicThread.java
@@ -82,7 +82,8 @@ public abstract class DynamicThread implements Runnable {
       // Thread too idle, exit if there is still enough threads
       int afterCnt = threadGroup.getThreadCnt().decrementAndGet();
       if (afterCnt >= threadGroup.getMinThreadCnt()) {
-        // notice that onThreadExit() will also decrease the counter, so we add it back here to avoid
+        // notice that onThreadExit() will also decrease the counter, so we add it back here to
+        // avoid
         // the counter being decreased twice
         threadGroup.getThreadCnt().incrementAndGet();
         return true;
diff --git a/node-commons/src/main/java/org/apache/iotdb/commons/concurrent/dynamic/DynamicThreadGroup.java b/node-commons/src/main/java/org/apache/iotdb/commons/concurrent/dynamic/DynamicThreadGroup.java
index 9d3199d0bb..c3531aab13 100644
--- a/node-commons/src/main/java/org/apache/iotdb/commons/concurrent/dynamic/DynamicThreadGroup.java
+++ b/node-commons/src/main/java/org/apache/iotdb/commons/concurrent/dynamic/DynamicThreadGroup.java
@@ -20,7 +20,6 @@ package org.apache.iotdb.commons.concurrent.dynamic;
 
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
@@ -36,8 +35,12 @@ public class DynamicThreadGroup {
   private int maxThreadCnt = 8;
   private Map<DynamicThread, Future<?>> threadFutureMap = new ConcurrentHashMap<>();
 
-  public DynamicThreadGroup(String name, Function<Runnable, Future<?>> poolSubmitter,
-      Supplier<DynamicThread> threadFactory, int minThreadCnt, int maxThreadCnt) {
+  public DynamicThreadGroup(
+      String name,
+      Function<Runnable, Future<?>> poolSubmitter,
+      Supplier<DynamicThread> threadFactory,
+      int minThreadCnt,
+      int maxThreadCnt) {
     this.name = name;
     this.poolSubmitter = poolSubmitter;
     this.threadFactory = threadFactory;
@@ -48,9 +51,7 @@ public class DynamicThreadGroup {
     }
   }
 
-  /**
-   * Add a thread to this group if the number of threads does not reach the maximum.
-   */
+  /** Add a thread to this group if the number of threads does not reach the maximum. */
   public void addThread() {
     int afterCnt = threadCnt.incrementAndGet();
     if (afterCnt <= maxThreadCnt) {
@@ -72,6 +73,7 @@ public class DynamicThreadGroup {
 
   /**
    * Remove a thread from the group when it exits.
+   *
    * @param dynamicThread exiting thread
    */
   public void onThreadExit(DynamicThread dynamicThread) {
@@ -80,7 +82,7 @@ public class DynamicThreadGroup {
   }
 
   public void cancelAll() {
-    threadFutureMap.forEach((t,f) -> f.cancel(true));
+    threadFutureMap.forEach((t, f) -> f.cancel(true));
     threadFutureMap.clear();
     threadCnt.set(0);
   }
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/flush/MemTableFlushTaskV2.java b/server/src/main/java/org/apache/iotdb/db/engine/flush/MemTableFlushTaskV2.java
index 75cc4d03cc..76ae732a3d 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/flush/MemTableFlushTaskV2.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/flush/MemTableFlushTaskV2.java
@@ -18,17 +18,6 @@
  */
 package org.apache.iotdb.db.engine.flush;
 
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.TimeUnit;
 import org.apache.iotdb.commons.concurrent.dynamic.DynamicThread;
 import org.apache.iotdb.commons.concurrent.dynamic.DynamicThreadGroup;
 import org.apache.iotdb.commons.service.metric.MetricService;
@@ -52,9 +41,22 @@ import org.apache.iotdb.metrics.utils.IoTDBMetricsUtils;
 import org.apache.iotdb.metrics.utils.MetricLevel;
 import org.apache.iotdb.tsfile.write.chunk.IChunkWriter;
 import org.apache.iotdb.tsfile.write.writer.RestorableTsFileIOWriter;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
 /**
  * flush task to flush one memtable using a pipeline model to flush, which is sort memtable ->
  * encoding -> write to disk (io task)
@@ -84,9 +86,8 @@ public class MemTableFlushTaskV2 {
   private FlushContext allContext;
 
   /**
-   * @param memTable     the memTable to flush
-   * @param writer       the writer where memTable will be flushed to (current tsfile writer or vm
-   *                     writer)
+   * @param memTable the memTable to flush
+   * @param writer the writer where memTable will be flushed to (current tsfile writer or vm writer)
    * @param storageGroup current database
    */
   public MemTableFlushTaskV2(
@@ -101,10 +102,20 @@ public class MemTableFlushTaskV2 {
     this.allContext.setWriter(writer);
     this.allContext.setMemTable(memTable);
 
-    this.sortTasks = new DynamicThreadGroup(storageGroup + "-" + dataRegionId + "-" + memTable,
-        SUB_TASK_POOL_MANAGER::submit, this::newSortThread, 1, 8);
-    this.encodingTasks = new DynamicThreadGroup(storageGroup + "-" + dataRegionId + "-" + memTable,
-        SUB_TASK_POOL_MANAGER::submit, this::newEncodingThread, 1, 8);
+    this.sortTasks =
+        new DynamicThreadGroup(
+            storageGroup + "-" + dataRegionId + "-" + memTable,
+            SUB_TASK_POOL_MANAGER::submit,
+            this::newSortThread,
+            1,
+            8);
+    this.encodingTasks =
+        new DynamicThreadGroup(
+            storageGroup + "-" + dataRegionId + "-" + memTable,
+            SUB_TASK_POOL_MANAGER::submit,
+            this::newEncodingThread,
+            1,
+            8);
     this.ioTaskFuture = SUB_TASK_POOL_MANAGER.submit(newIOThread());
     LOGGER.debug(
         "flush task of database {} memtable is created, flushing to file {}.",
@@ -112,10 +123,7 @@ public class MemTableFlushTaskV2 {
         allContext.getWriter().getFile().getName());
   }
 
-
-  /**
-   * the function for flushing memtable.
-   */
+  /** the function for flushing memtable. */
   public void syncFlushMemTable() throws ExecutionException, InterruptedException {
     long avgSeriesPointsNum =
         memTable.getSeriesNumber() == 0
@@ -151,8 +159,8 @@ public class MemTableFlushTaskV2 {
     List<IDeviceID> deviceIDList = new ArrayList<>(memTableMap.keySet());
     // sort the IDeviceID in lexicographical order
     deviceIDList.sort(Comparator.comparing(IDeviceID::toStringID));
-    deviceIDList.removeIf(d -> memTableMap.get(d).count() == 0 ||
-        memTableMap.get(d).getMemChunkMap().isEmpty());
+    deviceIDList.removeIf(
+        d -> memTableMap.get(d).count() == 0 || memTableMap.get(d).getMemChunkMap().isEmpty());
 
     allContext = new FlushContext();
     allContext.setDeviceContexts(new ArrayList<>());
@@ -215,8 +223,9 @@ public class MemTableFlushTaskV2 {
       if (estimatedTemporaryMemSize != 0) {
         SystemInfo.getInstance().releaseTemporaryMemoryForFlushing(estimatedTemporaryMemSize);
       }
-      SystemInfo.getInstance().setEncodingFasterThanIo(
-          allContext.getIoTime().get() >= allContext.getEncodingTime().get());
+      SystemInfo.getInstance()
+          .setEncodingFasterThanIo(
+              allContext.getIoTime().get() >= allContext.getEncodingTime().get());
     }
 
     MetricService.getInstance()
@@ -255,7 +264,6 @@ public class MemTableFlushTaskV2 {
     }
   }
 
-
   protected class TaskRunner extends DynamicThread {
 
     private static final String TASK_NAME_SORT = "sort data";
@@ -266,8 +274,12 @@ public class MemTableFlushTaskV2 {
     private BlockingQueue<Task> input;
     private BlockingQueue<Task> output;
 
-    public TaskRunner(DynamicThreadGroup threadGroup, Runnable cleanUp, String taskName,
-        BlockingQueue<Task> input, BlockingQueue<Task> output) {
+    public TaskRunner(
+        DynamicThreadGroup threadGroup,
+        Runnable cleanUp,
+        String taskName,
+        BlockingQueue<Task> input,
+        BlockingQueue<Task> output) {
       super(threadGroup);
       this.cleanUp = cleanUp;
       this.taskName = taskName;
@@ -304,21 +316,28 @@ public class MemTableFlushTaskV2 {
   }
 
   private DynamicThread newSortThread() {
-    return new TaskRunner(sortTasks, this::cleanSortThread, TaskRunner.TASK_NAME_SORT,
-        sortTaskQueue, encodingTaskQueue);
+    return new TaskRunner(
+        sortTasks,
+        this::cleanSortThread,
+        TaskRunner.TASK_NAME_SORT,
+        sortTaskQueue,
+        encodingTaskQueue);
   }
 
   private DynamicThread newEncodingThread() {
-    return new TaskRunner(encodingTasks, this::cleanEncodingThread, TaskRunner.TASK_NAME_ENCODING,
-        encodingTaskQueue, ioTaskQueue);
+    return new TaskRunner(
+        encodingTasks,
+        this::cleanEncodingThread,
+        TaskRunner.TASK_NAME_ENCODING,
+        encodingTaskQueue,
+        ioTaskQueue);
   }
 
   private DynamicThread newIOThread() {
-    return new TaskRunner(null, this::cleanIOThread, TaskRunner.TASK_NAME_IO,
-        ioTaskQueue, ioTaskQueue);
+    return new TaskRunner(
+        null, this::cleanIOThread, TaskRunner.TASK_NAME_IO, ioTaskQueue, ioTaskQueue);
   }
 
-
   private void cleanSortThread() {
     metricFlush();
     LOGGER.info(
@@ -326,8 +345,8 @@ public class MemTableFlushTaskV2 {
         storageGroup,
         allContext.getWriter().getFile().getName(),
         allContext.getSortTime().get());
-    WRITING_METRICS.recordFlushCost(WritingMetrics.FLUSH_STAGE_SORT,
-        allContext.getSortTime().get());
+    WRITING_METRICS.recordFlushCost(
+        WritingMetrics.FLUSH_STAGE_SORT, allContext.getSortTime().get());
   }
 
   private void cleanEncodingThread() {
@@ -337,9 +356,10 @@ public class MemTableFlushTaskV2 {
         storageGroup,
         allContext.getWriter().getFile().getName(),
         allContext.getEncodingTime().get());
-    WRITING_METRICS.recordFlushCost(WritingMetrics.FLUSH_STAGE_ENCODING,
-        allContext.getEncodingTime().get());
+    WRITING_METRICS.recordFlushCost(
+        WritingMetrics.FLUSH_STAGE_ENCODING, allContext.getEncodingTime().get());
   }
+
   private void cleanIOThread() {
     metricFlush();
     LOGGER.info(
@@ -348,8 +368,6 @@ public class MemTableFlushTaskV2 {
         allContext.getWriter().getFile().getName(),
         allContext.getIoTime().get());
     WRITING_METRICS.recordFlushCost(WritingMetrics.FLUSH_STAGE_IO, allContext.getIoTime().get());
-    WRITING_METRICS.recordFlushTsFileSize(storageGroup,
-        allContext.getWriter().getFile().length());
+    WRITING_METRICS.recordFlushTsFileSize(storageGroup, allContext.getWriter().getFile().length());
   }
-
 }
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/DeviceIOTask.java b/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/DeviceIOTask.java
index e7f0012efd..161853117c 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/DeviceIOTask.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/DeviceIOTask.java
@@ -18,11 +18,12 @@
  */
 package org.apache.iotdb.db.engine.flush.tasks;
 
-import java.io.IOException;
 import org.apache.iotdb.db.exception.runtime.FlushRunTimeException;
 import org.apache.iotdb.db.service.metrics.WritingMetrics;
 import org.apache.iotdb.tsfile.write.chunk.IChunkWriter;
 
+import java.io.IOException;
+
 public class DeviceIOTask implements Task {
   private FlushContext flushContext;
 
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/EncodeSeriesTask.java b/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/EncodeSeriesTask.java
index d6d6bfccd7..083db4ba5d 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/EncodeSeriesTask.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/EncodeSeriesTask.java
@@ -31,7 +31,10 @@ public class EncodeSeriesTask implements Task {
   private IWritableMemChunk series;
   private IChunkWriter chunkWriter;
 
-  public EncodeSeriesTask(IDeviceID deviceId, String seriesId, FlushDeviceContext deviceContext,
+  public EncodeSeriesTask(
+      IDeviceID deviceId,
+      String seriesId,
+      FlushDeviceContext deviceContext,
       FlushContext allContext,
       IWritableMemChunk series) {
     this.deviceId = deviceId;
@@ -63,7 +66,9 @@ public class EncodeSeriesTask implements Task {
     chunkWriter.clearPageWriter();
 
     long subTaskTime = System.currentTimeMillis() - starTime;
-    allContext.getWritingMetrics().recordFlushSubTaskCost(WritingMetrics.ENCODING_TASK, subTaskTime);
+    allContext
+        .getWritingMetrics()
+        .recordFlushSubTaskCost(WritingMetrics.ENCODING_TASK, subTaskTime);
     allContext.getEncodingTime().addAndGet(subTaskTime);
   }
 
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/FlushContext.java b/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/FlushContext.java
index 786f9211ac..6e4e2acb5e 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/FlushContext.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/FlushContext.java
@@ -18,13 +18,14 @@
  */
 package org.apache.iotdb.db.engine.flush.tasks;
 
-import java.util.List;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
 import org.apache.iotdb.db.engine.memtable.IMemTable;
 import org.apache.iotdb.db.service.metrics.recorder.WritingMetricsManager;
 import org.apache.iotdb.tsfile.write.writer.RestorableTsFileIOWriter;
 
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
 public class FlushContext {
   private final WritingMetricsManager WRITING_METRICS = WritingMetricsManager.getInstance();
   private List<FlushDeviceContext> deviceContexts;
@@ -43,7 +44,6 @@ public class FlushContext {
     this.deviceContexts = deviceContexts;
   }
 
-
   public int getCursor() {
     return cursor.get();
   }
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/FlushDeviceContext.java b/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/FlushDeviceContext.java
index a78d79ff89..9f5b70d4a4 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/FlushDeviceContext.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/FlushDeviceContext.java
@@ -18,11 +18,12 @@
  */
 package org.apache.iotdb.db.engine.flush.tasks;
 
+import org.apache.iotdb.db.metadata.idtable.entry.IDeviceID;
+import org.apache.iotdb.tsfile.write.chunk.IChunkWriter;
+
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
-import org.apache.iotdb.db.metadata.idtable.entry.IDeviceID;
-import org.apache.iotdb.tsfile.write.chunk.IChunkWriter;
 
 public class FlushDeviceContext {
   private IDeviceID deviceID;
@@ -31,7 +32,6 @@ public class FlushDeviceContext {
   private AtomicInteger encodedCounter = new AtomicInteger();
   private Map<String, Integer> seriesIndexMap;
 
-
   public AtomicInteger getEncodedCounter() {
     return encodedCounter;
   }
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/SortSeriesTask.java b/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/SortSeriesTask.java
index 96da7d91f3..e9d9f73711 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/SortSeriesTask.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/SortSeriesTask.java
@@ -22,7 +22,7 @@ import org.apache.iotdb.db.engine.memtable.IWritableMemChunk;
 import org.apache.iotdb.db.metadata.idtable.entry.IDeviceID;
 import org.apache.iotdb.db.service.metrics.WritingMetrics;
 
-public class SortSeriesTask implements Task{
+public class SortSeriesTask implements Task {
   private IDeviceID deviceId;
   private String seriesId;
   private FlushDeviceContext deviceContext;
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/Task.java b/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/Task.java
index 2bbd3ede2c..ee524be535 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/Task.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/flush/tasks/Task.java
@@ -20,5 +20,6 @@ package org.apache.iotdb.db.engine.flush.tasks;
 
 public interface Task {
   void run();
+
   Task nextTask();
 }