Merge
This commit is contained in:
commit
f1fbba23eb
make/modules/jdk.jstatd
src
hotspot
cpu/x86
assembler_x86.cppassembler_x86.hppc2_MacroAssembler_x86.cppc2_MacroAssembler_x86.hppstubGenerator_x86_64.cppx86.adx86_32.adx86_64.ad
share/jfr/leakprofiler/checkpoint
jdk.jfr/share/classes/jdk/jfr
test/jdk
jdk/incubator/vector
sun/tools/jstatd
@ -1,5 +1,5 @@
|
||||
#
|
||||
# Copyright (c) 2011, 2020, Oracle and/or its affiliates. All rights reserved.
|
||||
# Copyright (c) 2011, 2021, Oracle and/or its affiliates. All rights reserved.
|
||||
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
#
|
||||
# This code is free software; you can redistribute it and/or modify it
|
||||
@ -27,4 +27,5 @@ include LauncherCommon.gmk
|
||||
|
||||
$(eval $(call SetupBuildLauncher, jstatd, \
|
||||
MAIN_CLASS := sun.tools.jstatd.Jstatd, \
|
||||
JAVA_ARGS := -Djava.security.manager=allow, \
|
||||
))
|
||||
|
@ -2788,6 +2788,15 @@ void Assembler::kshiftlbl(KRegister dst, KRegister src, int imm8) {
|
||||
emit_int8(imm8);
|
||||
}
|
||||
|
||||
void Assembler::kshiftlql(KRegister dst, KRegister src, int imm8) {
|
||||
assert(VM_Version::supports_avx512bw(), "");
|
||||
InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
|
||||
int encode = vex_prefix_and_encode(dst->encoding(), 0 , src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
|
||||
emit_int16(0x33, (0xC0 | encode));
|
||||
emit_int8(imm8);
|
||||
}
|
||||
|
||||
|
||||
void Assembler::kshiftrbl(KRegister dst, KRegister src, int imm8) {
|
||||
assert(VM_Version::supports_avx512dq(), "");
|
||||
InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
|
||||
@ -2819,6 +2828,13 @@ void Assembler::kshiftrql(KRegister dst, KRegister src, int imm8) {
|
||||
emit_int8(imm8);
|
||||
}
|
||||
|
||||
void Assembler::kunpckdql(KRegister dst, KRegister src1, KRegister src2) {
|
||||
assert(VM_Version::supports_avx512bw(), "");
|
||||
InstructionAttr attributes(AVX_256bit, /* rex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
|
||||
int encode = vex_prefix_and_encode(dst->encoding(), src1->encoding(), src2->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
|
||||
emit_int16(0x4B, (0xC0 | encode));
|
||||
}
|
||||
|
||||
void Assembler::movb(Address dst, int imm8) {
|
||||
InstructionMark im(this);
|
||||
prefix(dst);
|
||||
|
@ -1510,12 +1510,15 @@ private:
|
||||
|
||||
void kxnorbl(KRegister dst, KRegister src1, KRegister src2);
|
||||
void kshiftlbl(KRegister dst, KRegister src, int imm8);
|
||||
void kshiftlql(KRegister dst, KRegister src, int imm8);
|
||||
void kshiftrbl(KRegister dst, KRegister src, int imm8);
|
||||
void kshiftrwl(KRegister dst, KRegister src, int imm8);
|
||||
void kshiftrdl(KRegister dst, KRegister src, int imm8);
|
||||
void kshiftrql(KRegister dst, KRegister src, int imm8);
|
||||
void ktestq(KRegister src1, KRegister src2);
|
||||
void ktestd(KRegister src1, KRegister src2);
|
||||
void kunpckdql(KRegister dst, KRegister src1, KRegister src2);
|
||||
|
||||
|
||||
void ktestql(KRegister dst, KRegister src);
|
||||
void ktestdl(KRegister dst, KRegister src);
|
||||
|
@ -4312,3 +4312,30 @@ void C2_MacroAssembler::vector_mask_operation(int opc, Register dst, XMMRegister
|
||||
vector_mask_operation_helper(opc, dst, tmp, masklen);
|
||||
}
|
||||
#endif
|
||||
|
||||
void C2_MacroAssembler::vector_maskall_operation(KRegister dst, Register src, int mask_len) {
|
||||
if (VM_Version::supports_avx512bw()) {
|
||||
if (mask_len > 32) {
|
||||
kmovql(dst, src);
|
||||
} else {
|
||||
kmovdl(dst, src);
|
||||
if (mask_len != 32) {
|
||||
kshiftrdl(dst, dst, 32 - mask_len);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
assert(mask_len <= 16, "");
|
||||
kmovwl(dst, src);
|
||||
if (mask_len != 16) {
|
||||
kshiftrwl(dst, dst, 16 - mask_len);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef _LP64
|
||||
void C2_MacroAssembler::vector_maskall_operation32(KRegister dst, Register src, KRegister tmp, int mask_len) {
|
||||
assert(VM_Version::supports_avx512bw(), "");
|
||||
kmovdl(tmp, src);
|
||||
kunpckdql(dst, tmp, tmp);
|
||||
}
|
||||
#endif
|
||||
|
@ -234,6 +234,12 @@ public:
|
||||
Register rtmp2, XMMRegister xtmp, int mask_len, int vec_enc);
|
||||
#endif
|
||||
|
||||
void vector_maskall_operation(KRegister dst, Register src, int mask_len);
|
||||
|
||||
#ifndef _LP64
|
||||
void vector_maskall_operation32(KRegister dst, Register src, KRegister ktmp, int mask_len);
|
||||
#endif
|
||||
|
||||
void string_indexof_char(Register str1, Register cnt1, Register ch, Register result,
|
||||
XMMRegister vec1, XMMRegister vec2, XMMRegister vec3, Register tmp);
|
||||
|
||||
|
@ -4138,6 +4138,7 @@ class StubGenerator: public StubCodeGenerator {
|
||||
const Register len = c_rarg3; // src len (must be multiple of blocksize 16)
|
||||
__ enter(); // required for proper stackwalking of RuntimeStub frame
|
||||
__ aesecb_encrypt(from, to, key, len);
|
||||
__ vzeroupper();
|
||||
__ leave(); // required for proper stackwalking of RuntimeStub frame
|
||||
__ ret(0);
|
||||
return start;
|
||||
@ -4153,6 +4154,7 @@ class StubGenerator: public StubCodeGenerator {
|
||||
const Register len = c_rarg3; // src len (must be multiple of blocksize 16)
|
||||
__ enter(); // required for proper stackwalking of RuntimeStub frame
|
||||
__ aesecb_decrypt(from, to, key, len);
|
||||
__ vzeroupper();
|
||||
__ leave(); // required for proper stackwalking of RuntimeStub frame
|
||||
__ ret(0);
|
||||
return start;
|
||||
@ -4452,6 +4454,7 @@ class StubGenerator: public StubCodeGenerator {
|
||||
__ movptr(avx512_subkeyHtbl, rsp);
|
||||
|
||||
__ aesgcm_encrypt(in, len, ct, out, key, state, subkeyHtbl, avx512_subkeyHtbl, counter);
|
||||
__ vzeroupper();
|
||||
|
||||
__ movq(rsp, rbp);
|
||||
__ pop(rbp);
|
||||
@ -4571,6 +4574,7 @@ class StubGenerator: public StubCodeGenerator {
|
||||
#endif
|
||||
__ push(rbx);
|
||||
__ aesctr_encrypt(from, to, key, counter, len_reg, used, used_addr, saved_encCounter_start);
|
||||
__ vzeroupper();
|
||||
// Restore state before leaving routine
|
||||
__ pop(rbx);
|
||||
#ifdef _WIN64
|
||||
@ -5191,6 +5195,7 @@ address generate_cipherBlockChaining_decryptVectorAESCrypt() {
|
||||
__ evpxorq(RK14, RK14, RK14, Assembler::AVX_512bit);
|
||||
|
||||
__ BIND(Lcbc_exit);
|
||||
__ vzeroupper();
|
||||
__ pop(rbx);
|
||||
#ifdef _WIN64
|
||||
__ movl(rax, len_mem);
|
||||
@ -7066,6 +7071,7 @@ address generate_avx_ghash_processBlocks() {
|
||||
__ shrdl(tmp4, tmp3);
|
||||
__ movl(Address(newArr, nIdx, Address::times_4), tmp4);
|
||||
__ BIND(Exit);
|
||||
__ vzeroupper();
|
||||
// Restore callee save registers.
|
||||
__ pop(tmp5);
|
||||
#ifdef _WINDOWS
|
||||
@ -7187,6 +7193,7 @@ address generate_avx_ghash_processBlocks() {
|
||||
__ movl(Address(newArr, idx, Address::times_4), tmp3);
|
||||
|
||||
__ BIND(Exit);
|
||||
__ vzeroupper();
|
||||
// Restore callee save registers.
|
||||
__ pop(tmp5);
|
||||
#ifdef _WINDOWS
|
||||
|
@ -1827,7 +1827,7 @@ const bool Matcher::match_rule_supported_vector(int opcode, int vlen, BasicType
|
||||
}
|
||||
break;
|
||||
case Op_MaskAll:
|
||||
if (!is_LP64 || !VM_Version::supports_evex()) {
|
||||
if (!VM_Version::supports_evex()) {
|
||||
return false;
|
||||
}
|
||||
if ((vlen > 16 || is_subword_type(bt)) && !VM_Version::supports_avx512bw()) {
|
||||
@ -9460,64 +9460,18 @@ instruct evcmp_masked(kReg dst, vec src1, vec src2, immI8 cond, kReg mask, rRegP
|
||||
ins_pipe( pipe_slow );
|
||||
%}
|
||||
|
||||
instruct mask_all_evexI_LE32(kReg dst, rRegI src) %{
|
||||
predicate(Matcher::vector_length(n) <= 32);
|
||||
match(Set dst (MaskAll src));
|
||||
format %{ "mask_all_evexI_LE32 $dst, $src \t" %}
|
||||
ins_encode %{
|
||||
int mask_len = Matcher::vector_length(this);
|
||||
__ vector_maskall_operation($dst$$KRegister, $src$$Register, mask_len);
|
||||
%}
|
||||
ins_pipe( pipe_slow );
|
||||
%}
|
||||
|
||||
#ifdef _LP64
|
||||
instruct mask_all_evexI_imm(kReg dst, immI cnt, rRegL tmp) %{
|
||||
match(Set dst (MaskAll cnt));
|
||||
effect(TEMP_DEF dst, TEMP tmp);
|
||||
format %{ "mask_all_evexI $dst, $cnt \t! using $tmp as TEMP" %}
|
||||
ins_encode %{
|
||||
int vec_len = Matcher::vector_length(this);
|
||||
if (VM_Version::supports_avx512bw()) {
|
||||
__ movq($tmp$$Register, $cnt$$constant);
|
||||
__ kmovql($dst$$KRegister, $tmp$$Register);
|
||||
__ kshiftrql($dst$$KRegister, $dst$$KRegister, 64 - vec_len);
|
||||
} else {
|
||||
assert(vec_len <= 16, "");
|
||||
__ movq($tmp$$Register, $cnt$$constant);
|
||||
__ kmovwl($dst$$KRegister, $tmp$$Register);
|
||||
__ kshiftrwl($dst$$KRegister, $dst$$KRegister, 16 - vec_len);
|
||||
}
|
||||
%}
|
||||
ins_pipe( pipe_slow );
|
||||
%}
|
||||
|
||||
instruct mask_all_evexI(kReg dst, rRegI src, rRegL tmp) %{
|
||||
match(Set dst (MaskAll src));
|
||||
effect(TEMP_DEF dst, TEMP tmp);
|
||||
format %{ "mask_all_evexI $dst, $src \t! using $tmp as TEMP" %}
|
||||
ins_encode %{
|
||||
int vec_len = Matcher::vector_length(this);
|
||||
if (VM_Version::supports_avx512bw()) {
|
||||
__ movslq($tmp$$Register, $src$$Register);
|
||||
__ kmovql($dst$$KRegister, $tmp$$Register);
|
||||
__ kshiftrql($dst$$KRegister, $dst$$KRegister, 64 - vec_len);
|
||||
} else {
|
||||
assert(vec_len <= 16, "");
|
||||
__ kmovwl($dst$$KRegister, $src$$Register);
|
||||
__ kshiftrwl($dst$$KRegister, $dst$$KRegister, 16 - vec_len);
|
||||
}
|
||||
%}
|
||||
ins_pipe( pipe_slow );
|
||||
%}
|
||||
|
||||
instruct mask_all_evexL(kReg dst, rRegL src) %{
|
||||
match(Set dst (MaskAll src));
|
||||
effect(TEMP_DEF dst);
|
||||
format %{ "mask_all_evexL $dst, $src \t! mask all operation" %}
|
||||
ins_encode %{
|
||||
int vec_len = Matcher::vector_length(this);
|
||||
if (VM_Version::supports_avx512bw()) {
|
||||
__ kmovql($dst$$KRegister, $src$$Register);
|
||||
__ kshiftrql($dst$$KRegister, $dst$$KRegister, 64 - vec_len);
|
||||
} else {
|
||||
assert(vec_len <= 16, "");
|
||||
__ kmovwl($dst$$KRegister, $src$$Register);
|
||||
__ kshiftrwl($dst$$KRegister, $dst$$KRegister, 16 - vec_len);
|
||||
}
|
||||
%}
|
||||
ins_pipe( pipe_slow );
|
||||
%}
|
||||
|
||||
instruct mask_not_immLT8(kReg dst, kReg src, rRegI rtmp, kReg ktmp, immI_M1 cnt) %{
|
||||
predicate(Matcher::vector_length(n) < 8 && VM_Version::supports_avx512dq());
|
||||
match(Set dst (XorVMask src (MaskAll cnt)));
|
||||
|
@ -13847,7 +13847,40 @@ instruct cmpFastUnlock(eFlagsReg cr, eRegP object, eAXRegP box, eRegP tmp ) %{
|
||||
ins_pipe(pipe_slow);
|
||||
%}
|
||||
|
||||
instruct mask_all_evexL_LT32(kReg dst, eRegL src) %{
|
||||
predicate(Matcher::vector_length(n) <= 32);
|
||||
match(Set dst (MaskAll src));
|
||||
format %{ "mask_all_evexL_LE32 $dst, $src \t" %}
|
||||
ins_encode %{
|
||||
int mask_len = Matcher::vector_length(this);
|
||||
__ vector_maskall_operation($dst$$KRegister, $src$$Register, mask_len);
|
||||
%}
|
||||
ins_pipe( pipe_slow );
|
||||
%}
|
||||
|
||||
instruct mask_all_evexL_GT32(kReg dst, eRegL src, kReg ktmp) %{
|
||||
predicate(Matcher::vector_length(n) > 32);
|
||||
match(Set dst (MaskAll src));
|
||||
effect(TEMP ktmp);
|
||||
format %{ "mask_all_evexL_GT32 $dst, $src \t! using $ktmp as TEMP " %}
|
||||
ins_encode %{
|
||||
int mask_len = Matcher::vector_length(this);
|
||||
__ vector_maskall_operation32($dst$$KRegister, $src$$Register, $ktmp$$KRegister, mask_len);
|
||||
%}
|
||||
ins_pipe( pipe_slow );
|
||||
%}
|
||||
|
||||
instruct mask_all_evexI_GT32(kReg dst, rRegI src, kReg ktmp) %{
|
||||
predicate(Matcher::vector_length(n) > 32);
|
||||
match(Set dst (MaskAll src));
|
||||
effect(TEMP ktmp);
|
||||
format %{ "mask_all_evexI_GT32 $dst, $src \t! using $ktmp as TEMP" %}
|
||||
ins_encode %{
|
||||
int mask_len = Matcher::vector_length(this);
|
||||
__ vector_maskall_operation32($dst$$KRegister, $src$$Register, $ktmp$$KRegister, mask_len);
|
||||
%}
|
||||
ins_pipe( pipe_slow );
|
||||
%}
|
||||
|
||||
// ============================================================================
|
||||
// Safepoint Instruction
|
||||
|
@ -13011,6 +13011,29 @@ instruct safePoint_poll_tls(rFlagsReg cr, rRegP poll)
|
||||
ins_pipe(ialu_reg_mem);
|
||||
%}
|
||||
|
||||
instruct mask_all_evexL(kReg dst, rRegL src) %{
|
||||
match(Set dst (MaskAll src));
|
||||
format %{ "mask_all_evexL $dst, $src \t! mask all operation" %}
|
||||
ins_encode %{
|
||||
int mask_len = Matcher::vector_length(this);
|
||||
__ vector_maskall_operation($dst$$KRegister, $src$$Register, mask_len);
|
||||
%}
|
||||
ins_pipe( pipe_slow );
|
||||
%}
|
||||
|
||||
instruct mask_all_evexI_GT32(kReg dst, rRegI src, rRegL tmp) %{
|
||||
predicate(Matcher::vector_length(n) > 32);
|
||||
match(Set dst (MaskAll src));
|
||||
effect(TEMP tmp);
|
||||
format %{ "mask_all_evexI_GT32 $dst, $src \t! using $tmp as TEMP" %}
|
||||
ins_encode %{
|
||||
int mask_len = Matcher::vector_length(this);
|
||||
__ movslq($tmp$$Register, $src$$Register);
|
||||
__ vector_maskall_operation($dst$$KRegister, $tmp$$Register, mask_len);
|
||||
%}
|
||||
ins_pipe( pipe_slow );
|
||||
%}
|
||||
|
||||
// ============================================================================
|
||||
// Procedure Call/Return Instructions
|
||||
// Call Java Static Instruction
|
||||
|
@ -202,7 +202,7 @@ static void prepare_for_resolution() {
|
||||
|
||||
static bool stack_trace_precondition(const ObjectSample* sample) {
|
||||
assert(sample != NULL, "invariant");
|
||||
return sample->has_stack_trace_id() && !sample->is_dead() && !sample->stacktrace().valid();
|
||||
return sample->has_stack_trace_id() && !sample->is_dead();
|
||||
}
|
||||
|
||||
class StackTraceBlobInstaller {
|
||||
@ -249,7 +249,7 @@ void StackTraceBlobInstaller::install(ObjectSample* sample) {
|
||||
writer.write_type(TYPE_STACKTRACE);
|
||||
writer.write_count(1);
|
||||
ObjectSampleCheckpoint::write_stacktrace(stack_trace, writer);
|
||||
blob = writer.move();
|
||||
blob = writer.copy();
|
||||
_cache.put(sample, blob);
|
||||
sample->set_stacktrace(blob);
|
||||
}
|
||||
@ -278,7 +278,7 @@ void ObjectSampleCheckpoint::on_rotation(const ObjectSampler* sampler) {
|
||||
}
|
||||
|
||||
static bool is_klass_unloaded(traceid klass_id) {
|
||||
assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
|
||||
assert(ClassLoaderDataGraph_lock->owned_by_self(), "invariant");
|
||||
return JfrKlassUnloading::is_unloaded(klass_id);
|
||||
}
|
||||
|
||||
@ -381,12 +381,6 @@ void ObjectSampleCheckpoint::write(const ObjectSampler* sampler, EdgeStore* edge
|
||||
assert(sampler != NULL, "invariant");
|
||||
assert(edge_store != NULL, "invariant");
|
||||
assert(thread != NULL, "invariant");
|
||||
{
|
||||
// First install stacktrace blobs for the most recently added candidates.
|
||||
MutexLocker lock(SafepointSynchronize::is_at_safepoint() ? nullptr : ClassLoaderDataGraph_lock);
|
||||
// the lock is needed to ensure the unload lists do not grow in the middle of inspection.
|
||||
install_stack_traces(sampler);
|
||||
}
|
||||
write_sample_blobs(sampler, emit_all, thread);
|
||||
// write reference chains
|
||||
if (!edge_store->is_empty()) {
|
||||
|
@ -41,6 +41,7 @@ import jdk.jfr.internal.Type;
|
||||
import jdk.jfr.internal.consumer.ChunkHeader;
|
||||
import jdk.jfr.internal.consumer.ChunkParser;
|
||||
import jdk.jfr.internal.consumer.FileAccess;
|
||||
import jdk.jfr.internal.consumer.ParserState;
|
||||
import jdk.jfr.internal.consumer.RecordingInput;
|
||||
|
||||
/**
|
||||
@ -61,6 +62,7 @@ import jdk.jfr.internal.consumer.RecordingInput;
|
||||
*/
|
||||
public final class RecordingFile implements Closeable {
|
||||
|
||||
private final ParserState parserState = new ParserState();
|
||||
private boolean isLastEventInChunk;
|
||||
private final File file;
|
||||
private RecordingInput input;
|
||||
@ -247,7 +249,7 @@ public final class RecordingFile implements Closeable {
|
||||
private void findNext() throws IOException {
|
||||
while (nextEvent == null) {
|
||||
if (chunkParser == null) {
|
||||
chunkParser = new ChunkParser(input);
|
||||
chunkParser = new ChunkParser(input, parserState);
|
||||
} else if (!chunkParser.isLastChunk()) {
|
||||
chunkParser = chunkParser.nextChunkParser();
|
||||
} else {
|
||||
|
@ -65,7 +65,7 @@ public abstract class AbstractEventStream implements EventStream {
|
||||
private volatile Thread thread;
|
||||
private Dispatcher dispatcher;
|
||||
|
||||
private volatile boolean closed;
|
||||
protected final ParserState parserState = new ParserState();
|
||||
|
||||
private boolean daemon = false;
|
||||
|
||||
@ -215,12 +215,12 @@ public abstract class AbstractEventStream implements EventStream {
|
||||
|
||||
protected abstract void process() throws IOException;
|
||||
|
||||
protected final void setClosed(boolean closed) {
|
||||
this.closed = closed;
|
||||
protected final void closeParser() {
|
||||
parserState.close();
|
||||
}
|
||||
|
||||
protected final boolean isClosed() {
|
||||
return closed;
|
||||
return parserState.isClosed();
|
||||
}
|
||||
|
||||
public final void startAsync(long startNanos) {
|
||||
|
@ -97,7 +97,7 @@ public final class ChunkParser {
|
||||
private final RecordingInput input;
|
||||
private final ChunkHeader chunkHeader;
|
||||
private final TimeConverter timeConverter;
|
||||
|
||||
private final ParserState parserState;
|
||||
private final LongMap<ConstantLookup> constantLookups;
|
||||
|
||||
private LongMap<Type> typeMap;
|
||||
@ -105,24 +105,24 @@ public final class ChunkParser {
|
||||
private boolean chunkFinished;
|
||||
|
||||
private ParserConfiguration configuration;
|
||||
private volatile boolean closed;
|
||||
private MetadataDescriptor previousMetadata;
|
||||
private MetadataDescriptor metadata;
|
||||
private boolean staleMetadata = true;
|
||||
|
||||
public ChunkParser(RecordingInput input) throws IOException {
|
||||
this(input, new ParserConfiguration());
|
||||
public ChunkParser(RecordingInput input, ParserState ps) throws IOException {
|
||||
this(input, new ParserConfiguration(), ps);
|
||||
}
|
||||
|
||||
ChunkParser(RecordingInput input, ParserConfiguration pc) throws IOException {
|
||||
this(new ChunkHeader(input), null, pc);
|
||||
ChunkParser(RecordingInput input, ParserConfiguration pc, ParserState ps) throws IOException {
|
||||
this(new ChunkHeader(input), null, pc, ps);
|
||||
}
|
||||
|
||||
private ChunkParser(ChunkParser previous) throws IOException {
|
||||
this(new ChunkHeader(previous.input), previous, new ParserConfiguration());
|
||||
private ChunkParser(ChunkParser previous, ParserState ps) throws IOException {
|
||||
this(new ChunkHeader(previous.input), previous, new ParserConfiguration(), ps);
|
||||
}
|
||||
|
||||
private ChunkParser(ChunkHeader header, ChunkParser previous, ParserConfiguration pc) throws IOException {
|
||||
private ChunkParser(ChunkHeader header, ChunkParser previous, ParserConfiguration pc, ParserState ps) throws IOException {
|
||||
this.parserState = ps;
|
||||
this.configuration = pc;
|
||||
this.input = header.getInput();
|
||||
this.chunkHeader = header;
|
||||
@ -155,7 +155,7 @@ public final class ChunkParser {
|
||||
}
|
||||
|
||||
public ChunkParser nextChunkParser() throws IOException {
|
||||
return new ChunkParser(chunkHeader.nextHeader(), this, configuration);
|
||||
return new ChunkParser(chunkHeader.nextHeader(), this, configuration, parserState);
|
||||
}
|
||||
|
||||
private void updateConfiguration() {
|
||||
@ -280,7 +280,7 @@ public final class ChunkParser {
|
||||
Logger.log(LogTag.JFR_SYSTEM_PARSER, LogLevel.INFO, "Waiting for more data (streaming). Read so far: " + chunkHeader.getChunkSize() + " bytes");
|
||||
}
|
||||
while (true) {
|
||||
if (closed) {
|
||||
if (parserState.isClosed()) {
|
||||
return true;
|
||||
}
|
||||
if (chunkHeader.getLastNanos() > filterEnd) {
|
||||
@ -437,7 +437,7 @@ public final class ChunkParser {
|
||||
}
|
||||
|
||||
ChunkParser newChunkParser() throws IOException {
|
||||
return new ChunkParser(this);
|
||||
return new ChunkParser(this, parserState);
|
||||
}
|
||||
|
||||
public boolean isChunkFinished() {
|
||||
@ -457,7 +457,7 @@ public final class ChunkParser {
|
||||
}
|
||||
|
||||
public void close() {
|
||||
this.closed = true;
|
||||
parserState.close();
|
||||
try {
|
||||
input.close();
|
||||
} catch(IOException e) {
|
||||
|
@ -83,7 +83,7 @@ public class EventDirectoryStream extends AbstractEventStream {
|
||||
|
||||
@Override
|
||||
public void close() {
|
||||
setClosed(true);
|
||||
closeParser();
|
||||
dispatcher().runCloseActions();
|
||||
repositoryFiles.close();
|
||||
if (currentParser != null) {
|
||||
@ -148,7 +148,7 @@ public class EventDirectoryStream extends AbstractEventStream {
|
||||
}
|
||||
currentChunkStartNanos = repositoryFiles.getTimestamp(path);
|
||||
try (RecordingInput input = new RecordingInput(path.toFile(), fileAccess)) {
|
||||
currentParser = new ChunkParser(input, disp.parserConfiguration);
|
||||
currentParser = new ChunkParser(input, disp.parserConfiguration, parserState);
|
||||
long segmentStart = currentParser.getStartNanos() + currentParser.getChunkDuration();
|
||||
long filterStart = validStartTime ? disp.startNanos : segmentStart;
|
||||
long filterEnd = disp.endTime != null ? disp.endNanos : Long.MAX_VALUE;
|
||||
|
@ -64,7 +64,7 @@ public final class EventFileStream extends AbstractEventStream {
|
||||
|
||||
@Override
|
||||
public void close() {
|
||||
setClosed(true);
|
||||
closeParser();
|
||||
dispatcher().runCloseActions();
|
||||
try {
|
||||
input.close();
|
||||
@ -85,7 +85,7 @@ public final class EventFileStream extends AbstractEventStream {
|
||||
end = disp.endNanos;
|
||||
}
|
||||
|
||||
currentParser = new ChunkParser(input, disp.parserConfiguration);
|
||||
currentParser = new ChunkParser(input, disp.parserConfiguration, parserState);
|
||||
while (!isClosed()) {
|
||||
onMetadata(currentParser);
|
||||
if (currentParser.getStartNanos() > end) {
|
||||
|
@ -0,0 +1,38 @@
|
||||
/*
|
||||
* Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
package jdk.jfr.internal.consumer;
|
||||
|
||||
public final class ParserState {
|
||||
private volatile boolean closed;
|
||||
|
||||
public boolean isClosed() {
|
||||
return closed;
|
||||
}
|
||||
|
||||
public void close() {
|
||||
closed = true;
|
||||
}
|
||||
}
|
@ -74,7 +74,7 @@ public final class ChunkFilename {
|
||||
|
||||
// If more than one file per second
|
||||
while (counter < MAX_CHUNK_NAMES) {
|
||||
String extendedName = String.format("%s_%02d%s", filename, counter, FILE_EXTENSION);
|
||||
String extendedName = makeExtendedName(filename, counter);
|
||||
p = directory.resolve(extendedName);
|
||||
counter++;
|
||||
if (!fileAcess.exists(p)) {
|
||||
@ -83,4 +83,16 @@ public final class ChunkFilename {
|
||||
}
|
||||
throw new IOException("Unable to find unused filename after " + counter + " attempts");
|
||||
}
|
||||
|
||||
private String makeExtendedName(String filename, int counter) {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
sb.append(filename);
|
||||
sb.append('_');
|
||||
if (counter < 10) { // chronological sorted
|
||||
sb.append('0');
|
||||
}
|
||||
sb.append(counter);
|
||||
sb.append(FILE_EXTENSION);
|
||||
return sb.toString();
|
||||
}
|
||||
}
|
||||
|
@ -24,7 +24,7 @@
|
||||
/*
|
||||
* @test
|
||||
* @modules jdk.incubator.vector
|
||||
* @run testng/othervm -ea -esa -Xbatch -XX:-TieredCompilation Byte512VectorTests
|
||||
* @run testng/othervm/timeout=240 -ea -esa -Xbatch -XX:-TieredCompilation Byte512VectorTests
|
||||
*/
|
||||
|
||||
// -- This file was mechanically generated: Do not edit! -- //
|
||||
|
@ -24,7 +24,7 @@
|
||||
/*
|
||||
* @test
|
||||
* @modules jdk.incubator.vector
|
||||
* @run testng/othervm -ea -esa -Xbatch -XX:-TieredCompilation ByteMaxVectorTests
|
||||
* @run testng/othervm/timeout=240 -ea -esa -Xbatch -XX:-TieredCompilation ByteMaxVectorTests
|
||||
*/
|
||||
|
||||
// -- This file was mechanically generated: Do not edit! -- //
|
||||
|
@ -39,7 +39,7 @@ import jdk.incubator.vector.VectorSpecies;
|
||||
* @test
|
||||
* @modules jdk.incubator.vector
|
||||
* @modules java.base/jdk.internal.vm.annotation
|
||||
* @run testng/othervm --add-opens jdk.incubator.vector/jdk.incubator.vector=ALL-UNNAMED
|
||||
* @run testng/othervm/timeout=240 --add-opens jdk.incubator.vector/jdk.incubator.vector=ALL-UNNAMED
|
||||
* -XX:-TieredCompilation VectorReshapeTests
|
||||
*/
|
||||
|
||||
|
@ -253,7 +253,6 @@ public final class JstatdTest {
|
||||
private String[] getJstatdCmd() throws Exception {
|
||||
JDKToolLauncher launcher = JDKToolLauncher.createUsingTestJDK("jstatd");
|
||||
launcher.addVMArg("-XX:+UsePerfData");
|
||||
launcher.addVMArg("-Djava.security.manager=allow");
|
||||
String testSrc = System.getProperty("test.src");
|
||||
File policy = new File(testSrc, "all.policy");
|
||||
assertTrue(policy.exists() && policy.isFile(),
|
||||
|
Loading…
x
Reference in New Issue
Block a user