Java BigArrays.NON_RECYCLING_INSTANCE属性代码示例

public void testHandshakeUpdatesVersion() throws IOException {
    assumeTrue("only tcp transport has a handshake method", serviceA.getOriginalTransport() instanceof TcpTransport);
    NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(Collections.emptyList());
    Version version = VersionUtils.randomVersionBetween(random(), Version.CURRENT.minimumCompatibilityVersion(), Version.CURRENT);
    try (MockTcpTransport transport = new MockTcpTransport(Settings.EMPTY, threadPool, BigArrays.NON_RECYCLING_INSTANCE,
        new NoneCircuitBreakerService(), namedWriteableRegistry, new NetworkService(Settings.EMPTY, Collections.emptyList()),version)) {
        transport.transportServiceAdapter(serviceA.new Adapter());
        transport.start();
        DiscoveryNode node =
            new DiscoveryNode("TS_TPC", "TS_TPC", transport.boundAddress().publishAddress(), emptyMap(), emptySet(),
                Version.fromString("2.0.0"));
        ConnectionProfile.Builder builder = new ConnectionProfile.Builder();
        builder.addConnections(1,
            TransportRequestOptions.Type.BULK,
            TransportRequestOptions.Type.PING,
            TransportRequestOptions.Type.RECOVERY,
            TransportRequestOptions.Type.REG,
            TransportRequestOptions.Type.STATE);
        try (Transport.Connection connection = serviceA.openConnection(node, builder.build())) {
            assertEquals(connection.getVersion(), version);
        }
    }
}
 

private NetworkHandle startServices(String nodeNameAndId, Settings settings, Version version) {
    MockTcpTransport transport =
            new MockTcpTransport(
                settings,
                    threadPool,
                    BigArrays.NON_RECYCLING_INSTANCE,
                    new NoneCircuitBreakerService(),
                    new NamedWriteableRegistry(Collections.emptyList()),
                    new NetworkService(settings, Collections.emptyList()));
    TransportService transportService = new MockTransportService(settings, transport, threadPool,
        TransportService.NOOP_TRANSPORT_INTERCEPTOR, (boundAddress) -> new DiscoveryNode(
        nodeNameAndId,
        nodeNameAndId,
        boundAddress.publishAddress(),
        emptyMap(),
        emptySet(),
        version), null);
    transportService.start();
    transportService.acceptIncomingRequests();
    transportServices.add(transportService);
    return new NetworkHandle(transportService, transportService.getLocalNode());
}
 

@Before
public void createTransportSvc() {
    MockTcpTransport transport =
        new MockTcpTransport(Settings.EMPTY,
                                threadPool,
                                BigArrays.NON_RECYCLING_INSTANCE,
                                new NoneCircuitBreakerService(),
                                new NamedWriteableRegistry(Collections.emptyList()),
                                new NetworkService(Settings.EMPTY, Collections.emptyList())) {
            @Override
            public BoundTransportAddress boundAddress() {
                return new BoundTransportAddress(
                    new TransportAddress[]{new TransportAddress(InetAddress.getLoopbackAddress(), 9300)},
                    new TransportAddress(InetAddress.getLoopbackAddress(), 9300)
                );
            }
        };
    transportService = new MockTransportService(Settings.EMPTY, transport, threadPool, TransportService.NOOP_TRANSPORT_INTERCEPTOR,
            null);
}
 

protected MockTransportService build(Settings settings, Version version) {
    NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(Collections.emptyList());
    MockTransportService transportService =
        new MockTransportService(
            Settings.builder()
                .put(settings)
                // trace zenfd actions but keep the default otherwise
                .put(TransportService.TRACE_LOG_EXCLUDE_SETTING.getKey(), singleton(TransportLivenessAction.NAME))
                .build(),
            new MockTcpTransport(settings, threadPool, BigArrays.NON_RECYCLING_INSTANCE, circuitBreakerService,
                namedWriteableRegistry, new NetworkService(settings, Collections.emptyList()), version),
            threadPool,
            TransportService.NOOP_TRANSPORT_INTERCEPTOR,
            (boundAddress) ->
                new DiscoveryNode(Node.NODE_NAME_SETTING.get(settings), boundAddress.publishAddress(),
                    Node.NODE_ATTRIBUTES.get(settings).getAsMap(), DiscoveryNode.getRolesFromSettings(settings), version),
            null);
    transportService.start();
    transportService.acceptIncomingRequests();
    return transportService;
}
 

public void testAccuracy() {
    final long bucket = randomInt(20);
    final int numValues = randomIntBetween(1, 100000);
    final int maxValue = randomIntBetween(1, randomBoolean() ? 1000: 100000);
    final int p = randomIntBetween(14, MAX_PRECISION);
    IntHashSet set = new IntHashSet();
    HyperLogLogPlusPlus e = new HyperLogLogPlusPlus(p, BigArrays.NON_RECYCLING_INSTANCE, 1);
    for (int i = 0; i < numValues; ++i) {
        final int n = randomInt(maxValue);
        set.add(n);
        final long hash = BitMixer.mix64(n);
        e.collect(bucket, hash);
        if (randomInt(100) == 0) {
            //System.out.println(e.cardinality(bucket) + " <> " + set.size());
            assertThat((double) e.cardinality(bucket), closeTo(set.size(), 0.1 * set.size()));
        }
    }
    assertThat((double) e.cardinality(bucket), closeTo(set.size(), 0.1 * set.size()));
}
 

@Override
public InternalAggregation doReduce(List<InternalAggregation> aggregations, ReduceContext reduceContext) {
    InternalCardinality reduced = null;
    for (InternalAggregation aggregation : aggregations) {
        final InternalCardinality cardinality = (InternalCardinality) aggregation;
        if (cardinality.counts != null) {
            if (reduced == null) {
                reduced = new InternalCardinality(name, new HyperLogLogPlusPlus(cardinality.counts.precision(),
                        BigArrays.NON_RECYCLING_INSTANCE, 1), this.valueFormatter, pipelineAggregators(), getMetaData());
            }
            reduced.merge(cardinality);
        }
    }

    if (reduced == null) { // all empty
        return aggregations.get(0);
    } else {
        return reduced;
    }
}
 

/**
 * creates a new initializing shard.
 *
 * @param routing              shard routing to use
 * @param shardPath            path to use for shard data
 * @param indexMetaData        indexMetaData for the shard, including any mapping
 * @param indexSearcherWrapper an optional wrapper to be used during searchers
 * @param listeners            an optional set of listeners to add to the shard
 */
protected IndexShard newShard(ShardRouting routing, ShardPath shardPath, IndexMetaData indexMetaData,
                              @Nullable IndexSearcherWrapper indexSearcherWrapper,
                              Runnable globalCheckpointSyncer,
                              @Nullable EngineFactory engineFactory,
                              IndexingOperationListener... listeners) throws IOException {
    final Settings nodeSettings = Settings.builder().put("node.name", routing.currentNodeId()).build();
    final IndexSettings indexSettings = new IndexSettings(indexMetaData, nodeSettings);
    final IndexShard indexShard;
    final Store store = createStore(indexSettings, shardPath);
    boolean success = false;
    try {
        IndexCache indexCache = new IndexCache(indexSettings, new DisabledQueryCache(indexSettings), null);
        MapperService mapperService = MapperTestUtils.newMapperService(xContentRegistry(), createTempDir(),
                indexSettings.getSettings());
        mapperService.merge(indexMetaData, MapperService.MergeReason.MAPPING_RECOVERY, true);
        SimilarityService similarityService = new SimilarityService(indexSettings, Collections.emptyMap());
        final IndexEventListener indexEventListener = new IndexEventListener() {
        };
        final Engine.Warmer warmer = searcher -> {
        };
        IndicesFieldDataCache indicesFieldDataCache = new IndicesFieldDataCache(nodeSettings, new IndexFieldDataCache.Listener() {
        });
        IndexFieldDataService indexFieldDataService = new IndexFieldDataService(indexSettings, indicesFieldDataCache,
            new NoneCircuitBreakerService(), mapperService);
        indexShard = new IndexShard(routing, indexSettings, shardPath, store, indexCache, mapperService, similarityService,
            indexFieldDataService, engineFactory, indexEventListener, indexSearcherWrapper, threadPool,
            BigArrays.NON_RECYCLING_INSTANCE, warmer, globalCheckpointSyncer, Collections.emptyList(), Arrays.asList(listeners));
        success = true;
    } finally {
        if (success == false) {
            IOUtils.close(store);
        }
    }
    return indexShard;
}
 

public void testShortcutQueryAndFetchOptimization() throws IOException {
    SearchPhaseController controller = new SearchPhaseController(Settings.EMPTY, BigArrays.NON_RECYCLING_INSTANCE, null);
    MockSearchPhaseContext mockSearchPhaseContext = new MockSearchPhaseContext(1);
    InitialSearchPhase.SearchPhaseResults<QuerySearchResultProvider> results =
        controller.newSearchPhaseResults(mockSearchPhaseContext.getRequest(), 1);
    AtomicReference<SearchResponse> responseRef = new AtomicReference<>();
    boolean hasHits = randomBoolean();
    final int numHits;
    if (hasHits) {
        QuerySearchResult queryResult = new QuerySearchResult();
        queryResult.topDocs(new TopDocs(1, new ScoreDoc[] {new ScoreDoc(42, 1.0F)}, 1.0F), new DocValueFormat[0]);
        queryResult.size(1);
        FetchSearchResult fetchResult = new FetchSearchResult();
        fetchResult.hits(new SearchHits(new SearchHit[] {new SearchHit(42)}, 1, 1.0F));
        results.consumeResult(0, new QueryFetchSearchResult(queryResult, fetchResult));
        numHits = 1;
    } else {
        numHits = 0;
    }

    FetchSearchPhase phase = new FetchSearchPhase(results, controller, mockSearchPhaseContext,
        (searchResponse) -> new SearchPhase("test") {
        @Override
        public void run() throws IOException {
            responseRef.set(searchResponse);
        }
    });
    assertEquals("fetch", phase.getName());
    phase.run();
    mockSearchPhaseContext.assertNoFailure();
    assertNotNull(responseRef.get());
    assertEquals(numHits, responseRef.get().getHits().totalHits);
    if (numHits != 0) {
        assertEquals(42, responseRef.get().getHits().getAt(0).docId());
    }
    assertTrue(mockSearchPhaseContext.releasedSearchContexts.isEmpty());
}
 

@Override
public InternalAggregation buildAggregation(long owningBucketOrdinal) {
    if (counts == null || owningBucketOrdinal >= counts.maxBucket() || counts.cardinality(owningBucketOrdinal) == 0) {
        return buildEmptyAggregation();
    }
    // We need to build a copy because the returned Aggregation needs remain usable after
    // this Aggregator (and its HLL++ counters) is released.
    HyperLogLogPlusPlus copy = new HyperLogLogPlusPlus(precision, BigArrays.NON_RECYCLING_INSTANCE, 1);
    copy.merge(0, counts, owningBucketOrdinal);
    return new InternalCardinality(name, copy, formatter, pipelineAggregators(), metaData());
}
 

public void testPortLimit() throws InterruptedException {
    final NetworkService networkService = new NetworkService(Settings.EMPTY, Collections.emptyList());
    final Transport transport = new MockTcpTransport(
        Settings.EMPTY,
        threadPool,
        BigArrays.NON_RECYCLING_INSTANCE,
        new NoneCircuitBreakerService(),
        new NamedWriteableRegistry(Collections.emptyList()),
        networkService,
        Version.CURRENT) {

        @Override
        public BoundTransportAddress boundAddress() {
            return new BoundTransportAddress(
                new TransportAddress[]{new TransportAddress(InetAddress.getLoopbackAddress(), 9500)},
                new TransportAddress(InetAddress.getLoopbackAddress(), 9500)
            );
        }
    };
    closeables.push(transport);
    final TransportService transportService =
        new TransportService(Settings.EMPTY, transport, threadPool, TransportService.NOOP_TRANSPORT_INTERCEPTOR, x -> null, null);
    closeables.push(transportService);
    final int limitPortCounts = randomIntBetween(1, 10);
    final List<DiscoveryNode> discoveryNodes = TestUnicastZenPing.resolveHostsLists(
        executorService,
        logger,
        Collections.singletonList("127.0.0.1"),
        limitPortCounts,
        transportService,
        "test_",
        TimeValue.timeValueSeconds(1));
    assertThat(discoveryNodes, hasSize(limitPortCounts));
    final Set<Integer> ports = new HashSet<>();
    for (final DiscoveryNode discoveryNode : discoveryNodes) {
        assertTrue(discoveryNode.getAddress().address().getAddress().isLoopbackAddress());
        ports.add(discoveryNode.getAddress().getPort());
    }
    assertThat(ports, equalTo(IntStream.range(9300, 9300 + limitPortCounts).mapToObj(m -> m).collect(Collectors.toSet())));
}
 

public TestNode(String name, ThreadPool threadPool, Settings settings) {
    final Function<BoundTransportAddress, DiscoveryNode> boundTransportAddressDiscoveryNodeFunction =
        address -> {
         discoveryNode.set(new DiscoveryNode(name, address.publishAddress(), emptyMap(), emptySet(), Version.CURRENT));
         return discoveryNode.get();
        };
    transportService = new TransportService(settings,
            new MockTcpTransport(settings, threadPool, BigArrays.NON_RECYCLING_INSTANCE, new NoneCircuitBreakerService(),
                new NamedWriteableRegistry(ClusterModule.getNamedWriteables()),
                new NetworkService(settings, Collections.emptyList())),
            threadPool, TransportService.NOOP_TRANSPORT_INTERCEPTOR, boundTransportAddressDiscoveryNodeFunction, null) {
        @Override
        protected TaskManager createTaskManager() {
            if (MockTaskManager.USE_MOCK_TASK_MANAGER_SETTING.get(settings)) {
                return new MockTaskManager(settings);
            } else {
                return super.createTaskManager();
            }
        }
    };
    transportService.start();
    clusterService = createClusterService(threadPool, discoveryNode.get());
    clusterService.addStateApplier(transportService.getTaskManager());
    IndexNameExpressionResolver indexNameExpressionResolver = new IndexNameExpressionResolver(settings);
    ActionFilters actionFilters = new ActionFilters(emptySet());
    transportListTasksAction = new TransportListTasksAction(settings, threadPool, clusterService, transportService,
            actionFilters, indexNameExpressionResolver);
    transportCancelTasksAction = new TransportCancelTasksAction(settings, threadPool, clusterService,
            transportService, actionFilters, indexNameExpressionResolver);
    transportService.acceptIncomingRequests();
}
 

public void testMerge() {
    final int p = randomIntBetween(MIN_PRECISION, MAX_PRECISION);
    final HyperLogLogPlusPlus single = new HyperLogLogPlusPlus(p, BigArrays.NON_RECYCLING_INSTANCE, 0);
    final HyperLogLogPlusPlus[] multi = new HyperLogLogPlusPlus[randomIntBetween(2, 100)];
    final long[] bucketOrds = new long[multi.length];
    for (int i = 0; i < multi.length; ++i) {
        bucketOrds[i] = randomInt(20);
        multi[i] = new HyperLogLogPlusPlus(p, BigArrays.NON_RECYCLING_INSTANCE, 5);
    }
    final int numValues = randomIntBetween(1, 100000);
    final int maxValue = randomIntBetween(1, randomBoolean() ? 1000: 1000000);
    for (int i = 0; i < numValues; ++i) {
        final int n = randomInt(maxValue);
        final long hash = BitMixer.mix64(n);
        single.collect(0, hash);
        // use a gaussian so that all instances don't collect as many hashes
        final int index = (int) (Math.pow(randomDouble(), 2));
        multi[index].collect(bucketOrds[index], hash);
        if (randomInt(100) == 0) {
            HyperLogLogPlusPlus merged = new HyperLogLogPlusPlus(p, BigArrays.NON_RECYCLING_INSTANCE, 0);
            for (int j = 0; j < multi.length; ++j) {
                merged.merge(0, multi[j], bucketOrds[j]);
            }
            assertEquals(single.cardinality(0), merged.cardinality(0));
        }
    }
}
 

protected Translog createTranslog(Path translogPath) throws IOException {
    TranslogConfig translogConfig = new TranslogConfig(shardId, translogPath, INDEX_SETTINGS, BigArrays.NON_RECYCLING_INSTANCE);
    return new Translog(translogConfig, null, () -> SequenceNumbersService.UNASSIGNED_SEQ_NO);
}
 

@Before
public void setup() {
    searchPhaseController = new SearchPhaseController(Settings.EMPTY, BigArrays.NON_RECYCLING_INSTANCE, null);
}
 

private void assertAgainstReference(boolean docFreq, boolean totalTermFreq, Query filter, Map<String, FreqHolder> reference) throws Exception {
    FreqTermsEnum freqTermsEnum = new FreqTermsEnum(reader, "field", docFreq, totalTermFreq, filter, BigArrays.NON_RECYCLING_INSTANCE);
    assertAgainstReference(freqTermsEnum, reference, docFreq, totalTermFreq);
}