Java Streams-ը բենչմարկների փորձության մեջ
Դիտարկելով Java ExecutorService ինտերֆեյսը և նրա իրականացումները՝ հիմա ստուգում ենք, թե ինչպես են Fork/Join framework-ը և ThreadPerTaskExecutor-ը դիմանում ծանրաբեռնվածությանը։
Նախորդ անգամ ավելի մոտիկից ուսումնասիրեցի Java ExecutorService ինտերֆեյսը և նրա իրականացումները՝ հատուկ ուշադրություն դարձնելով Fork/Join framework-ին և ThreadPerTaskExecutor-ին։ Այս անգամ ուզում եմ մեկ քայլ առաջ գնալ և տեսնել, թե ինչպես են դրանք դիմանում ծանրաբեռնվածությանը։ Պարզ ասած՝ ես բենչմարկներ եմ գործարկելու, ընդ որում՝ շատ։
Բենչմարկի տրամաբանությունը
Սկսեմ այն տրամաբանության անցումից, որի վրա կառուցված են բենչմարկները, քանի որ այն բաժանվում է երկու հիմնական կատեգորիայի.
- դասական stream-ի վրա հիմնված
- Fork/Join մոտեցման վրա հիմնված
Դասական Stream-ի տրամաբանություն
public static Map<Ip, Integer> groupByIncomingIp(Stream<String> requests,
LocalDateTime upperTimeBound, LocalDateTime lowerTimeBound) {
return requests
.map(line -> line.split(","))
.filter(words -> words.length == 3)
.map(words -> new Request(words[1], LocalDateTime.parse(words[2])))
.filter(request -> request.timestamp().isBefore(upperTimeBound) &&
request.timestamp().isAfter(lowerTimeBound))
.map(i -> new Ip(i.ip()))
.collect(groupingBy(i -> i, summingInt(i -> 1)));
}
Սկզբունքորեն այս կոդը վերցնում է տողերի ցուցակ, փոխակերպում է այն, կիրառում է որոշ ֆիլտրում և խմբավորում և վերադարձնում է map։ Ստացվող տողերն ունեն հետևյալ տեսքը.
1,192.168.1.1,2023-10-29T17:33:33.647641574
Յուրաքանչյուրը ներկայացնում է իրադարձություն, երբ IP հասցեն փորձում է մուտք գործել տվյալ սերվեր։ Արդյունքը յուրաքանչյուր IP հասցեին համապատասխանեցնում է մուտքի փորձերի քանակը տվյալ ժամանակահատվածում, որը սահմանվում է ստորին և վերին ժամանակային սահմաններով։
Fork/Join տրամաբանություն
@Override
public Map<Ip, Integer> compute() {
if (data.size() >= THRESHOLD) {
Map<Ip, Integer> output = new HashMap<>();
ForkJoinTask
.invokeAll(createSubTasks())
.forEach(task -> task
.join()
.forEach((k, v) -> updateOutput(k, v, output))
);
return output;
}
return process();
}
private void updateOutput(Ip k, Integer v, Map<Ip, Integer> output) {
Integer currentValue = output.get(k);
if (currentValue == null) {
output.put(k, v);
} else {
output.replace(k, currentValue + v);
}
}
private List<ForkJoinDefinition> createSubTasks() {
int size = data.size();
int middle = size / 2;
return List.of(
new ForkJoinDefinition(new ArrayList<>(data.subList(0, middle)), now),
new ForkJoinDefinition(new ArrayList<>(data.subList(middle, size)), now)
);
}
private Map<Ip, Integer> process() {
return groupByIncomingIp(data.stream(), upperTimeBound, lowerTimeBound);
}
Միակ էական տարբերությունն այն է, որ ես շարունակում եմ տվյալների հավաքածուն բաժանել ավելի փոքր խմբաքանակների, մինչև այն հասնի տրված շեմին, որի լռելյայն արժեքը 20 է։ Միայն դրանից հետո եմ սկսում հաշվարկները, որոնք նույնական են վերևում նկարագրված դասական stream-ի տրամաբանության հաշվարկներին. ես օգտագործում եմ groupByIncomingIp մեթոդը։
JMH-ի կարգավորումը
Յուրաքանչյուր բենչմարկ գրված է Java Microbenchmark Harness-ով (կարճ՝ JMH)։
Բենչմարկները գործարկել եմ JMH 1.37 տարբերակով։ Բոլորն օգտագործում են նույն կարգավորումը՝ հինգ տաքացման իտերացիա, որին հաջորդում են քսան չափման իտերացիա։
Օգտագործվում են երկու տարբեր ռեժիմներ՝ միջին ժամանակ և թողունակություն։ Միջին ժամանակի դեպքում JMH-ը չափում է բենչմարկվող կոդի կատարման միջին ժամանակը, և արդյունքը տրվում է միլիվայրկյաններով։
Թողունակության դեպքում JMH-ը հաշվում է, թե քանի գործողություն՝ կոդի ամբողջական կատարում, է տեղավորվում ժամանակի տրված միավորում, այստեղ՝ միլիվայրկյանում։ Արդյունքը տրվում է ops/միլիվայրկյան միավորով։
JMH-ի տերմիններով արտահայտած.
@Warmup(iterations = 5, time = 10, timeUnit = SECONDS)
@Measurement(iterations = 20, time = 10, timeUnit = SECONDS)
@BenchmarkMode({Mode.AverageTime, Mode.Throughput})
@OutputTimeUnit(MILLISECONDS)
@Fork(1)
@Threads(1)
Բացի այդ, յուրաքանչյուր բենչմարկ ունի իր սեփական State-ը՝ Benchmark շրջանակով, որը պահում է այդ բենչմարկին անհրաժեշտ բոլոր տվյալներն ու փոփոխականները։
Բենչմարկի State-ը
Դասական Stream
Ստորև կարող եք տեսնել Classic Stream-ի բազային բենչմարկի state-ը։
@State(Scope.Benchmark)
public class BenchmarkState {
@Param({"0"})
public int size;
public List<String> input;
public ClassicDefinition definitions;
public ForkJoinPool forkJoinPool_4;
public ForkJoinPool forkJoinPool_8;
public ForkJoinPool forkJoinPool_16;
public ForkJoinPool forkJoinPool_32;
private final LocalDateTime now = LocalDateTime.now();
@Setup(Level.Trial)
public void trialUp() {
input = new TestDataGen(now).generate(size);
definitions = new ClassicDefinition(now);
System.out.println(input.size());
}
@Setup(Level.Iteration)
public void up() {
forkJoinPool_4 = new ForkJoinPool(4);
forkJoinPool_8 = new ForkJoinPool(8);
forkJoinPool_16 = new ForkJoinPool(16);
forkJoinPool_32 = new ForkJoinPool(32);
}
@TearDown(Level.Iteration)
public void down() {
forkJoinPool_4.shutdown();
forkJoinPool_8.shutdown();
forkJoinPool_16.shutdown();
forkJoinPool_32.shutdown();
}
}
Սկզբում նախապատրաստում եմ բենչմարկներին անհրաժեշտ յուրաքանչյուր փոփոխական։ Բացի size պարամետրից, որն այստեղ հատուկ դեր ունի, thread pool-երն օգտագործվում են միայն բենչմարկի ներսում։
size պարամետրը, ընդհակառակը, JMH-ի տրամադրած բավականին հետաքրքիր մեխանիզմ է։ Այն թույլ է տալիս պարամետրիզացնել բենչմարկի ընթացքում օգտագործվող տրված փոփոխականը։ Ավելի ուշ, երբ հասնենք բենչմարկների գործարկմանը, կտեսնեք, թե ինչպես եմ օգտագործել այն։
Առայժմ ես այս պարամետրը օգտագործում եմ մուտքային տվյալների հավաքածուն գեներացնելու համար, որը մնում է նույնը ամբողջ բենչմարկի ընթացքում, որպեսզի արդյունքներն ավելի կրկնելի լինեն։
Հաջորդը up մեթոդն է, որը վարվում է շատ նման JUnit գրադարանի @BeforeEach-ին։
Այն աշխատում է իմ բենչմարկի 20 իտերացիաներից յուրաքանչյուրից առաջ և զրոյացնում է բենչմարկի օգտագործած բոլոր փոփոխականները։ Այսպես յուրաքանչյուր իտերացիա սկսվում է մաքուր վիճակից։
Վերջապես կա down մեթոդը, որը վարվում է շատ նման JUnit գրադարանի @AfterEach-ին։
Այն աշխատում է իմ բենչմարկի 20 իտերացիաներից յուրաքանչյուրից հետո և փակում է այդ իտերացիայում օգտագործված բոլոր thread pool-երը՝ հիմնականում հիշողության հնարավոր արտահոսքերի հետ գործ ունենալու համար։
Fork/Join
Ահա թե ինչպիսին է Fork/Join տարբերակի state-ը։
@State(Scope.Benchmark)
public class ForkJoinState {
@Param({"0"})
public int size;
public List<String> input;
public ForkJoinPool forkJoinPool_4;
public ForkJoinPool forkJoinPool_8;
public ForkJoinPool forkJoinPool_16;
public ForkJoinPool forkJoinPool_32;
public final LocalDateTime now = LocalDateTime.now();
@Setup(Level.Trial)
public void trialUp() {
input = new TestDataGen(now).generate(size);
System.out.println(input.size());
}
@Setup(Level.Iteration)
public void up() {
forkJoinPool_4 = new ForkJoinPool(4);
forkJoinPool_8 = new ForkJoinPool(8);
forkJoinPool_16 = new ForkJoinPool(16);
forkJoinPool_32 = new ForkJoinPool(32);
}
@TearDown(Level.Iteration)
public void down() {
forkJoinPool_4.shutdown();
forkJoinPool_8.shutdown();
forkJoinPool_16.shutdown();
forkJoinPool_32.shutdown();
}
}
Դասական stream-ի և Fork/Join-ի կարգավորումները հազիվ են տարբերվում։ Միակ տարբերությունն այն է, որ definitions-ները ստեղծվում են հենց բենչմարկների ներսում, այլ ոչ state-ում, ինչպես Classic մոտեցման դեպքում։
Այս փոփոխությունը բխում է RecursiveTask-ի աշխատանքի ձևից. առաջադրանքների կատարումները memoize են արվում և պահվում, ինչը կարող է ազդել բենչմարկի ընդհանուր արդյունքների վրա։
Բենչմարկի մուտքային տվյալները
Բենչմարկների հիմնական մուտքը այս ձևաչափով տողերի ցուցակ է
1,192.168.1.1,2023-10-29T17:33:33.647641574
կամ, ավելի ընդհանուր նկարագրած
{ordering-number},{ip-like-string},{timestamp}
Օգտագործվում են մուտքի հինգ տարբեր չափեր.
- 100
- 1000
- 10000
- 100000
- 1000000
Այս չափերն ընտրված չեն պատահականորեն. կարծում եմ, նման միջակայքը կարող է ցույց տալ, թե որքան լավ է լուծումը մասշտաբավորվում, և կարող է բացահայտել արդյունավետության խոչընդոտը։
Բենչմարկի կարգավորումը նաև ընդհանուր առմամբ շատ ճկուն է, ուստի ցանկացողը, ով ուզում է ավելացնել մեկ այլ չափ, պետք է կարողանա դա անել առանց մեծ դժվարության։
Բենչմարկի կարգավորումը
Դասական Stream
Դասական stream բենչմարկը բաղկացած է ընդամենը մեկ դասից։ Տարբեր չափերը կառավարվում են State մակարդակում։
public class ClassicStreamBenchmark extends BaseBenchmarkConfig {
@Benchmark
public void bench_sequential(SingleStreamState state, Blackhole bh) {
Map<String, Integer> map = state.definitions.sequentialStream(state.input);
bh.consume(map);
}
@Benchmark
public void bench_defaultParallelStream(SingleStreamState state, Blackhole bh) {
Map<String, Integer> map = state.definitions.defaultParallelStream(state.input);
bh.consume(map);
}
@Benchmark
public void bench_parallelStreamWithCustomForkJoinPool_4(SingleStreamState state, Blackhole bh) {
Map<String, Integer> map = state.definitions.parallelStreamWithCustomForkJoinPool(state.forkJoinPool_4, state.input);
bh.consume(map);
}
@Benchmark
public void bench_parallelStreamWithCustomForkJoinPool_8(SingleStreamState state, Blackhole bh) {
Map<String, Integer> map = state.definitions.parallelStreamWithCustomForkJoinPool(state.forkJoinPool_8, state.input);
bh.consume(map);
}
@Benchmark
public void bench_parallelStreamWithCustomForkJoinPool_16(SingleStreamState state, Blackhole bh) {
Map<String, Integer> map = state.definitions.parallelStreamWithCustomForkJoinPool(state.forkJoinPool_16, state.input);
bh.consume(map);
}
@Benchmark
public void bench_parallelStreamWithCustomForkJoinPool_32(SingleStreamState state, Blackhole bh) {
Map<String, Integer> map = state.definitions.parallelStreamWithCustomForkJoinPool(state.forkJoinPool_32, state.input);
bh.consume(map);
}
}
Նույն տրամաբանությունը բենչմարկվում է վեց տարբեր կարգավորումներով.
- bench_sequential -> հիմնական բենչմարկ՝ օգտագործելով միայն մեկ հաջորդական stream
- bench_defaultParallelStream -> բենչմարկ՝ օգտագործելով Java-ի լռելյայն զուգահեռ stream-ը
Streamդասի .parallelStream() մեթոդով, ինչը գործնականում նշանակում է ForkJoinPool-իcommonPool՝ 19 զուգահեռականությամբ (գոնե իմ մեքենայում) - bench_parallelStreamWithCustomForkJoinPool_4 -> սեփական
ForkJoinPool, որի զուգահեռականության մակարդակը 4 է - bench_parallelStreamWithCustomForkJoinPool_8 -> սեփական
ForkJoinPool, որի զուգահեռականության մակարդակը 8 է - bench_parallelStreamWithCustomForkJoinPool_16 -> սեփական
ForkJoinPool, որի զուգահեռականության մակարդակը 16 է - bench_parallelStreamWithCustomForkJoinPool_32 -> սեփական
ForkJoinPool, որի զուգահեռականության մակարդակը 32 է
Դասական stream-ի տրամաբանության համար 6 տարբեր կարգավորումները 5 տարբեր մուտքային չափերի հետ համակցելով՝ ստանում ենք ընդհանուր առմամբ 30 եզակի բենչմարկ համակցություն։
Fork/Join
public class ForkJoinBenchmark extends BaseBenchmarkConfig {
@Benchmark
public void bench(ForkJoinState state, Blackhole bh) {
Map<Ip, Integer> map = new ForkJoinDefinition(state.input, state.now).compute();
bh.consume(map);
}
@Benchmark
public void bench_customForkJoinPool_4(ForkJoinState state, Blackhole bh) {
ForkJoinDefinition forkJoinDefinition = new ForkJoinDefinition(state.input, state.now);
Map<Ip, Integer> map = state.forkJoinPool_4.invoke(forkJoinDefinition);
bh.consume(map);
}
@Benchmark
public void bench_customForkJoinPool_8(ForkJoinState state, Blackhole bh) {
ForkJoinDefinition forkJoinDefinition = new ForkJoinDefinition(state.input, state.now);
Map<Ip, Integer> map = state.forkJoinPool_8.invoke(forkJoinDefinition);
bh.consume(map);
}
@Benchmark
public void bench_customForkJoinPool_16(ForkJoinState state, Blackhole bh) {
ForkJoinDefinition forkJoinDefinition = new ForkJoinDefinition(state.input, state.now);
Map<Ip, Integer> map = state.forkJoinPool_16.invoke(forkJoinDefinition);
bh.consume(map);
}
@Benchmark
public void bench_customForkJoinPool_32(ForkJoinState state, Blackhole bh) {
ForkJoinDefinition forkJoinDefinition = new ForkJoinDefinition(state.input, state.now);
Map<Ip, Integer> map = state.forkJoinPool_32.invoke(forkJoinDefinition);
bh.consume(map);
}
}
Նույն տրամաբանությունը բենչմարկվում է վեց տարբեր կարգավորումներով.
- bench -> հիմնական բենչմարկ՝ օգտագործելով միայն մեկ հաջորդական stream
- bench_customForkJoinPool_4 -> սեփական ForkJoinPool, որի զուգահեռականության մակարդակը 4 է
- bench_customForkJoinPool_8 -> սեփական ForkJoinPool, որի զուգահեռականության մակարդակը 8 է
- bench_customForkJoinPool_16 -> սեփական ForkJoinPool, որի զուգահեռականության մակարդակը 16 է
- bench_customForkJoinPool_32 -> սեփական ForkJoinPool, որի զուգահեռականության մակարդակը 32 է
Դասական stream-ի տրամաբանության համար 5 տարբեր կարգավորումները 5 տարբեր մուտքային չափերի հետ համակցելով՝ ստանում ենք ընդհանուր առմամբ 25 եզակի բենչմարկ համակցություն։
Բացի այդ, երկու դեպքում էլ օգտագործվում է JMH Blackhole հասկացությունը՝ կոմպիլյատորի dead code օպտիմալացումը «խաբելու» համար։ Blackhole-ների և դրանք երբ օգտագործելու մասին կարող եք կարդալ այստեղ։
Բենչմարկի միջավայրը
Մեքենա 1
Թեստերը կատարել ենք իմ Dell XPS-ի վրա, որն ունի հետևյալ պարամետրերը՝
OS: Ubuntu 20.04.6 LTS
CPU: i9-12900HK × 20
Հիշողություն՝ 64 GB
JVM
openjdk version “21” 2023-09-19
OpenJDK Runtime Environment (build 21+35-2513)
OpenJDK 64-Bit Server VM (build 21+35-2513, mixed mode, sharing)
Մեքենա 2
Թեստերը կատարել ենք իմ Lenovo Y700-ի վրա, որն ունի հետևյալ պարամետրերը՝
OS: Ubuntu 20.04.6 LTS
CPU: i7-6700HQ × 8
Հիշողություն՝ 32 GB
JVM
openjdk version “21” 2023-09-19
OpenJDK Runtime Environment (build 21+35-2513)
OpenJDK 64-Bit Server VM (build 21+35-2513, mixed mode, sharing)
Երկու մեքենաների վրա էլ բոլոր երկրորդական կամ անկարևոր հավելվածները փակված էին։ Ես ձգտել եմ գործարկման համակարգը պահել հնարավորինս մաքուր, որպեսզի չառաջանա անցանկալի արդյունավետության հավելյալ ծախս։ Այնուհանդերձ, ընդհանուր արդյունավետությունը կարող է տարբերվել մերկ Ubuntu սերվերի վրա կամ կոնտեյների ներսում աշխատելիս։
Բենչմարկի հաշվետվությունը
Բենչմարկի արդյունքները պահվում են .csv ֆայլերում, որոնք գտնվում են GitHub-ի repository-ում՝ reports դիրեկտորիայում։ Հաշվետվությունները ներբեռնելը հեշտացնելու համար կա նաև առանձին .zip ֆայլ՝ reports.zip անունով, որը պարունակում է բոլոր .csv տվյալների ֆայլերը։
Հաշվետվությունների դիրեկտորիաները կազմակերպված են ըստ չափի, գումարած երեք հատուկ հաշվետվություններ, որոնք ընդգրկում են մուտքի բոլոր չափերը.
- report_classic - մուտքի բոլոր չափերը դասական stream-ի համար
- report_forkjoin - մուտքի բոլոր չափերը fork/join stream-ի համար
- report_whole - մուտքի բոլոր չափերը և՛ դասական, և՛ fork/join stream-երի համար
Վերոնշյալ հաշվետվությունների դիրեկտորիաներից յուրաքանչյուրը պարունակում է 3 առանձին ֆայլ.
- averagetime.csv - միջին ժամանակի ռեժիմի բենչմարկների արդյունքները
- throughput.csv - թողունակության ռեժիմի բենչմարկների արդյունքները
- total.csv - երկու ռեժիմների համակցված արդյունքները
Այս հաշվետվությունները երկու ձևաչափով են. averagetime.csv-ն և throughput.csv-ն կիսում են մեկը, իսկ total.csv-ն օգտագործում է մյուսը։ Կոչենք դրանք ռեժիմների ձևաչափ և ընդհանուր ձևաչափ։
Ռեժիմների հաշվետվությունը ունի ութ սյունակ.
- Label - բենչմարկի անվանումը
- Input Size - բենչմարկի մուտքի չափը
- Threads - բենչմարկի օգտագործած թրեդների քանակը՝ 1,4,7,8,16,19,32 բազմությունից
- Mode - բենչմարկի ռեժիմը՝ average time կամ throughput
- Cnt - բենչմարկի իտերացիաների քանակը, որը միշտ պետք է լինի 20
- Score - բենչմարկի իրական արդյունքը
- Score Mean Error - բենչմարկի չափման սխալը
- Units - բենչմարկի միավորները՝ ms/op (average time-ի համար) կամ ops/ms (throughput-ի համար**)**
Ընդհանուր հաշվետվությունը ունի 10 սյունակ.
- Label - բենչմարկի անվանումը
- Input Size - բենչմարկի մուտքի չափը
- Threads - բենչմարկի օգտագործած թրեդների քանակը՝ 1,4,7,8,16,19,32 բազմությունից
- Cnt - բենչմարկի իտերացիաների քանակը, որը միշտ պետք է լինի 20
- AvgTimeScore - բենչմարկի իրական արդյունքը average time ռեժիմում
- AvgTimeMeanError - բենչմարկի չափման սխալը average time ռեժիմում
- AvgUnits - բենչմարկի միավորները average time ռեժիմում՝ ms/op-ով
- ThroughputScore - բենչմարկի իրական արդյունքը
- ThroughputMeanError - բենչմարկի չափման սխալը throughput ռեժիմում
- ThroughputUnits - բենչմարկի միավորները throughput ռեժիմում՝ ops/ms-ով
Արդյունքների վերլուծությունը
Ենթադրություններ
Բազային գիծ
Իմ ներկայացրած ընդհանուր արդյունքներն ու եզրահանգումները հիմնված են 10000 չափի վրա, այսինքն՝ ես օգտագործում եմ report_10000 դիրեկտորիայի .csv ֆայլերը։
Տվյալների այս կոնկրետ չափն ընտրել եմ երկու հիմնական պատճառով.
- Կատարման ժամանակը բավականաչափ երկար է՝ կարգավորումների միջև ցանկացած տարբերություն բացահայտելու համար։
- Իմ կարծիքով՝ 100 և 1000 տվյալների չափերը չափազանց փոքր են որոշ արդյունավետության խոչընդոտներ բացահայտելու համար
Այդ պատճառով կարծում եմ, որ տվյալների այս չափի մանրամասն վերլուծությունը ամենաարժեքավորը կլինի։
Բնականաբար, մյուս չափերի արդյունքների մասին նույնպես ակնարկ կտրվի, թեև ոչ այնքան մանրամասն, եթե չհանդիպեմ անոմալիաների՝ համեմատած 10000 չափի վարքագծի հետ։
Խոսք Fork/Join-ի բնիկ մոտեցման մասին
Հաշվի առնելով այժմ բենչմարկվող կոդը՝ Fork/Join բենչմարկներն ունեն արդյունավետության որոշ հավելյալ ծախս։
Քանի որ fork join բենչմարկի տրամաբանությունը մեծապես կախված է մուտքային տվյալների հավաքածուի բաժանումից, ինչ-որ պահի բոլոր մասնակի արդյունքները պետք է միավորվեն մեկ համահունչ ելքի մեջ։ Այս քայլը բացակայում է սովորական բենչմարկներում, ուստի կարևոր է պատշաճ հասկանալ, թե ինչպես է այն ազդում ընդհանուր արդյունավետության վրա։
Խնդրում եմ սա հիշել։
Վերլուծություն
Մեքենա 1 (20 միջուկ)
Ինչպես ցույց տրվեց վերևում, մեքենա 1-ի վրա 10 հազար մուտքի համար լավագույն ընդհանուր արդյունքը տալիս են defaultParallelStream տարբերակները։
ClassicStream-ի վրա հիմնված բենչմարկների շարքում bench_defaultParallelStream-ը տալիս է ամենալավ արդյունքը՝ մեծ տարբերությամբ։ Այն մնում է առաջին տեղում նույնիսկ չափման հնարավոր սխալը հաշվի առնելուց հետո։
32 և 16 զուգահեռականությամբ ForkJoinPool կարգավորումները տալիս են ավելի վատ արդյունքներ։ Մի իմաստով սա զարմանալի է. 32 զուգահեռականության դեպքում ես կսպասեի ավելի լավ գնահատական, քան լռելյայն pool-ի դեպքում (19 զուգահեռականություն)։ Մեկ այլ իմաստով՝ ոչ. 16 զուգահեռականությունը աշխատում է ավելի վատ, քան և՛ 19-ը, և՛ 32-ը։
Քանի որ Մեքենա 1-ը ունի 20 CPU թրեդ, 32 զուգահեռականությունը բավականաչափ բարձր չէ՝ չափազանց շատ թրեդներ ունենալու պատճառած արդյունավետության անկումը ցույց տալու համար։ Սակայն այդպիսի վարքագիծ կտեսնեք Մեքենա 2-ի վրա։ Ենթադրում եմ, որ Մեքենա 1-ի վրա այն վերարտադրելու համար զուգահեռականությունը պետք է դնել 64 կամ ավելի։
Հետաքրքիր է, որ bench_defaultParallelStream-ը, կարծես, չի մնում առաջին տեղում ավելի մեծ՝ 100 հազար և մեկ միլիոն մուտքի չափերի համար։ Այստեղ լավագույն արդյունավետությունը ցույց է տալիս bench_parallelStreamWithCustomForkJoinPool_16-ը, ինչը կարող է հուշել, որ ողջամտորեն ավելի ցածր զուգահեռականությունը ի վերջո կարող է լավ ընտրություն լինել։
Fork/Join-ի վրա հիմնված իրականացումը ակնհայտորեն ավելի դանդաղ է, քան լռելյայն զուգահեռ stream իրականացումը՝ աշխատելով մոտ 10 % ավելի վատ։ Նույն օրինաչափությունը երևում է նաև մյուս չափերի համար։ Սա հաստատում է իմ ավելի վաղ ենթադրությունը, որ բաժանված տվյալների փոքր մասերի միավորումը նկատելի արժեք ունի։
Անակնկալ չէ, որ միաթրեդ մոտեցումը ստանում է ամենավատ գնահատականը՝ լավագույն արդյունքից մոտ 5 անգամ դանդաղ։ Սա սպասելի է, քանի որ ես միաթրեդ բենչմարկը դիտարկում եմ որպես մի տեսակ բազային գիծ։ Ուզում եմ տեսնել, թե որքան կարելի է բարելավել նրա կատարման ժամանակը, և լավագույն դեպքում 5 անգամ ավելի լավ միջին կատարման ժամանակը լավ արդյունք է թվում։
Score mean error-ը չափազանց փոքր է։ Նույնիսկ ամենավատ դեպքում (ամենաբարձր սխալը) այն մնում է համապատասխան գնահատականի 1,5%-ի սահմաններում. սա ClassicStreamBenchmark.bench_parallelStreamWithCustomForkJoinPool_4-ի արդյունքն է։
Մնացած դեպքերում այն տատանվում է ընդհանուր գնահատականի 0,1 %-ից մինչև 0,7 %։
10 հազարից մեծ չափերի համար արդյունքների դասակարգումը, կարծես, չի փոխվում։
Մեքենա 2 (8 միջուկ)
Ճիշտ ինչպես Մեքենա 1-ի վրա, լավագույն գնահատականը կրկին պատկանում է bench_defaultParallelStream-ին։ Եվ կրկին այն մնում է առաջին տեղում նույնիսկ չափման հնարավոր սխալը հաշվի առնելիս։ Առանձնապես նշանակալի ոչինչ չկա։
Սակայն նշանակալի է, որ Մեքենա 2-ի վրա առաջին 3 տեղերի կարգը զգալիորեն փոխվում է ավելի մեծ մուտքային չափերի դեպքում։ 100-ից 10 000 մուտքերի համար վարքագիծը բավականին նման է. bench_defaultParallelStream-ը 1-ին տեղում է, իսկ bench_parallelStreamWithCustomForkJoinPool_8-ը՝ անմիջապես հետևում։
Իսկ 100 000 և 1 000 000 մուտքերի դեպքում, ընդհակառակը, առաջին տեղը զբաղեցնում է bench_parallelStreamWithCustomForkJoinPool_8-ը, իսկ դրանից անմիջապես հետո՝ bench_parallelStreamWithCustomForkJoinPool_32-ը։ Այդ ընթացքում bench_defaultParallelStream-ը իջնում է 4-րդ և 3-րդ տեղեր
Մեքենա 2-ի մեկ այլ հետաքրքիր կողմն այն է, որ փոքր մուտքային չափերի դեպքում 32 զուգահեռականությունը հեռու է գագաթից։ Արդյունավետության այս անկումը կարող է պայմանավորված լինել մեքենայի ունեցած ընդհանուր 8 CPU թրեդների համեմատ չափազանց շատ թրեդներ ունենալով։
Այդուհանդերձ, 100 000 և 1 000 000 մուտքերի դեպքում 32 զուգահեռականությամբ ForkJoinPool-ը զբաղեցնում է երկրորդ տեղը, ինչը կարող է հուշել, որ ավելի երկար ժամանակահատվածներում չափազանց շատ թրեդներ ունենալը խնդիր չէ։
Մի քանի այլ կողմեր, որոնք սերտորեն արտացոլում են Մեքենա 1-ի վարքագիծը, այստեղ բաց են թողնված և նկարագրված են ստորև։
Ընդհանուր կետեր
Որոշ դիտարկումներ ճիշտ են երկու մեքենաների համար.
- Իմ ForkJoinNative («naive») վրա հիմնված բենչմարկները տալիս են ակնհայտորեն ավելի վատ արդյունքներ՝ երկու մեքենաների վրա էլ մոտ 10%, քան լռելյայն զուգահեռ stream տարբերակները կամ նույնիսկ customForkJoinPool օգտագործողները։
Բնականաբար, պատճառի մի մասն այն է, որ դրանք բոլորովին օպտիմալացված չեն, և հավանաբար կան արդյունավետության հեշտ շահույթներ։ Այդ պատճառով խստորեն խորհուրդ եմ տալիս լավ ծանոթանալ Fork/Join framework-ին՝ նախքան դրա իրականացումները production տանելը։ - Առաջին և երրորդ տեղերի միջև ժամանակային տարբերությունը աննշան է՝ մեկ միլիվայրկյանից պակաս։ Սա կարող է դժվարացնել այս բենչմարկների որևէ իմաստալից վերարտադրումը։ Նման փոքր տարբերության դեպքում արդյունքների բաշխումը հեշտությամբ կարող է փոխվել բենչմարկի մի գործարկումից մյուսը։
- Գնահատականների mean Error-ը նույնպես աննշան է՝ վատագույն դեպքերում առավելագույնը ընդհանուր գնահատականի 2%, իսկ սովորաբար՝ 1%-ից ցածր։ Այսքան ցածր սխալը կարող է մատնանշել երկու բան։ Նախ՝ բենչմարկները հուսալի են, քանի որ արդյունքները խմբավորվում են որոշակի կետի շուրջ. եթե անոմալիաներ լինեին, սխալը ավելի մեծ կլիներ։ Երկրորդ՝ JMH-ը լավ է կատարում չափումները։
- Թողունակության և միջին ժամանակի ռեժիմները չեն տալիս սկզբունքորեն տարբեր արդյունքներ։ Բենչմարկը, որը լավ է հանդես եկել average time ռեժիմում, լավ է հանդես եկել նաև throughput ռեժիմում։
Սրանք բոլոր տարբերություններն ու նմանություններն են, որ նկատել եմ հաշվետվության ֆայլերում։ Եթե ևս ինչ-որ բան ուշադրություն գրավի որպես հետաքրքիր, ազատ զգացեք նշել այն ստորև մեկնաբանություններում։
Ամփոփում
Մինչ այսօր բաժանվելը՝ կա ևս մեկ շատ կարևոր բան, որ ուզում եմ նշել։
JAVA-Ն ԴԱՆԴԱՂ ՉԷ
Մեկ միլիոն տարրից կազմված ցուցակի մշակումը՝ JMH-ի բոլոր հնարավոր հավելյալ ծախսերով և մեկ թրեդով, տևում է 560 միլիվայրկյան (Մեքենա 1) և 1142 միլիվայրկյան (Մեքենա 2)։ Ոչ մի հատուկ օպտիմալացում կամ հնարք չի կիրառվել՝ պարզապես սովորական լռելյայն JVM։
Մեկ միլիոն տարրի մշակման լավագույն ընդհանուր ժամանակը Մեքենա 1-ի վրա եղել է 88 միլիվայրկյան, ինչին հասել է ClassicStreamBenchmark.bench_parallelStreamWithCustomForkJoinPool_16-ը։ Մեքենա 2-ի վրա այն եղել է 321 միլիվայրկյան, ինչին հասել է ClassicStreamBenchmark.bench_parallelStreamWithCustomForkJoinPool_8-ը։
Հնարավոր է՝ ոչ մի արդյունք չհամընկնի C/C++-ի վրա հիմնված լուծումներին, բայց իմ կարծիքով այս մոտեցման համեմատական պարզությունն ու արտահայտչականությունը այն դարձնում են շատ գրավիչ։
Ընդհանուր առմամբ՝ սա Java-ի one billion rows challenge-ի շատ գեղեցիկ լրացում է։
Կարող եք գործարկել նույն բենչմարկները՝ իմ արդյունքները համեմատելու համար, թե ինչպես են դրանք աշխատում Ձեր սեփական մեքենայի վրա։
Նաև հաշվետվությունները ներբեռնելը հեշտացնելու համար կա առանձին .zip ֆայլ՝ reports.zip անունով, որը պարունակում է բոլոր .csv տվյալների ֆայլերը։
Եվ հիշեք. Java-ն դանդաղ չէ։
Շնորհակալություն Ձեր ժամանակի համար։