Performance optimization for primitive Dynamic***Property classes

archaius-core/src/main/java/com/netflix/config/CachedDynamicBooleanProperty.java

@@ -0,0 +1,67 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ *
+ * Licensed 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 com.netflix.config;
+
+/**
+ * An implementation of {@link DynamicBooleanProperty} that caches the primitive value whenever it is changed.
+ *
+ * This can give improved performance due to avoiding the unboxing, at the expense of additional
+ * memory usage.
+ *
+ * @author Mike Smith
+ *
+ */
+public class CachedDynamicBooleanProperty extends DynamicBooleanProperty {
+
+    protected volatile boolean primitiveValue;
+
+    public CachedDynamicBooleanProperty(String propName, boolean defaultValue) {
+        super(propName, defaultValue);
+
+        // Set the initial value of the cached primitive value.
+        this.primitiveValue = chooseValue();
+    }
+
+    @Override
+    protected void propertyChanged() {
+        // Update the cached primitive value when the property is changed.
+        this.primitiveValue = chooseValue();
+    }
+
+    /**
+     * Get the current value from the underlying DynamicProperty
+     *
+     * @return
+     */
+    protected boolean chooseValue() {
+        return prop.getBoolean(defaultValue).booleanValue();
+    }
+
+    /**
+     * Get the current cached value.
+     *
+     * @return
+     */
+    @Override
+    public boolean get() {
+        return primitiveValue;
+    }
+
+    @Override
+    public Boolean getValue() {
+        return get();
+    }
+}

archaius-core/src/main/java/com/netflix/config/CachedDynamicDoubleProperty.java

@@ -0,0 +1,67 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ *
+ * Licensed 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 com.netflix.config;
+
+/**
+ * An implementation of {@link DynamicDoubleProperty} that caches the primitive value whenever it is changed.
+ *
+ * This can give improved performance due to avoiding the unboxing, at the expense of additional
+ * memory usage.
+ *
+ * @author Mike Smith
+ *
+ */
+public class CachedDynamicDoubleProperty extends DynamicDoubleProperty {
+
+    protected volatile double primitiveValue;
+
+    public CachedDynamicDoubleProperty(String propName, double defaultValue) {
+        super(propName, defaultValue);
+
+        // Set the initial value of the cached primitive value.
+        this.primitiveValue = chooseValue();
+    }
+
+    @Override
+    protected void propertyChanged() {
+        // Update the cached primitive value when the property is changed.
+        this.primitiveValue = chooseValue();
+    }
+
+    /**
+     * Get the current value from the underlying DynamicProperty
+     *
+     * @return
+     */
+    protected double chooseValue() {
+        return prop.getDouble(defaultValue).doubleValue();
+    }
+
+    /**
+     * Get the current cached value.
+     *
+     * @return
+     */
+    @Override
+    public double get() {
+        return primitiveValue;
+    }
+
+    @Override
+    public Double getValue() {
+        return get();
+    }
+}

archaius-core/src/main/java/com/netflix/config/CachedDynamicFloatProperty.java

@@ -0,0 +1,67 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ *
+ * Licensed 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 com.netflix.config;
+
+/**
+ * An implementation of {@link DynamicFloatProperty} that caches the primitive value whenever it is changed.
+ *
+ * This can give improved performance due to avoiding the unboxing, at the expense of additional
+ * memory usage.
+ *
+ * @author Mike Smith
+ *
+ */
+public class CachedDynamicFloatProperty extends DynamicFloatProperty {
+
+    protected volatile float primitiveValue;
+
+    public CachedDynamicFloatProperty(String propName, float defaultValue) {
+        super(propName, defaultValue);
+
+        // Set the initial value of the cached primitive value.
+        this.primitiveValue = chooseValue();
+    }
+
+    @Override
+    protected void propertyChanged() {
+        // Update the cached primitive value when the property is changed.
+        this.primitiveValue = chooseValue();
+    }
+
+    /**
+     * Get the current value from the underlying DynamicProperty
+     *
+     * @return
+     */
+    protected float chooseValue() {
+        return prop.getFloat(defaultValue).floatValue();
+    }
+
+    /**
+     * Get the current cached value.
+     *
+     * @return
+     */
+    @Override
+    public float get() {
+        return primitiveValue;
+    }
+
+    @Override
+    public Float getValue() {
+        return get();
+    }
+}

archaius-core/src/main/java/com/netflix/config/CachedDynamicIntProperty.java

@@ -0,0 +1,67 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ *
+ * Licensed 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 com.netflix.config;
+
+/**
+ * An implementation of {@link DynamicIntProperty} that caches the primitive value whenever it is changed.
+ *
+ * This can give improved performance due to avoiding the unboxing, at the expense of additional
+ * memory usage.
+ *
+ * @author Mike Smith
+ *
+ */
+public class CachedDynamicIntProperty extends DynamicIntProperty {
+
+    protected volatile int primitiveValue;
+
+    public CachedDynamicIntProperty(String propName, int defaultValue) {
+        super(propName, defaultValue);
+
+        // Set the initial value of the cached primitive value.
+        this.primitiveValue = chooseValue();
+    }
+
+    @Override
+    protected void propertyChanged() {
+        // Update the cached primitive value when the property is changed.
+        this.primitiveValue = chooseValue();
+    }
+
+    /**
+     * Get the current value from the underlying DynamicProperty
+     *
+     * @return
+     */
+    protected int chooseValue() {
+        return prop.getInteger(defaultValue).intValue();
+    }
+
+    /**
+     * Get the current cached value.
+     *
+     * @return
+     */
+    @Override
+    public int get() {
+        return primitiveValue;
+    }
+
+    @Override
+    public Integer getValue() {
+        return get();
+    }
+}

archaius-core/src/main/java/com/netflix/config/CachedDynamicLongProperty.java

@@ -0,0 +1,67 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ *
+ * Licensed 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 com.netflix.config;
+
+/**
+ * An implementation of {@link DynamicLongProperty} that caches the primitive value whenever it is changed.
+ *
+ * This can give improved performance due to avoiding the unboxing, at the expense of additional
+ * memory usage.
+ *
+ * @author Mike Smith
+ *
+ */
+public class CachedDynamicLongProperty extends DynamicLongProperty {
+
+    protected volatile long primitiveValue;
+
+    public CachedDynamicLongProperty(String propName, long defaultValue) {
+        super(propName, Long.valueOf(defaultValue));
+
+        // Set the initial value of the cached primitive value.
+        this.primitiveValue = chooseValue();
+    }
+
+    @Override
+    protected void propertyChanged() {
+        // Update the cached primitive value when the property is changed.
+        this.primitiveValue = chooseValue();
+    }
+
+    /**
+     * Get the current value from the underlying DynamicProperty
+     *
+     * @return
+     */
+    protected long chooseValue() {
+        return prop.getLong(defaultValue).longValue();
+    }
+
+    /**
+     * Get the current cached value.
+     *
+     * @return
+     */
+    @Override
+    public long get() {
+        return primitiveValue;
+    }
+
+    @Override
+    public Long getValue() {
+        return get();
+    }
+}

archaius-core/src/test/java/com/netflix/config/CachedPropertiesPerfTest.java

@@ -0,0 +1,56 @@
+package com.netflix.config;
+
+/**
+ * Simple benchmark impl to compare the caching of primitive boolean value in CachedDynamicBooleanProperty with
+ * the original implementation.
+ *
+ * @author Mike Smith
+ * Date: 11/25/15
+ */
+public class CachedPropertiesPerfTest
+{
+    public static void main(String[] args)
+    {
+        try {
+            long loopCount = 4000000000l;
+
+            // Run twice.
+            runTest(loopCount);
+            runTest(loopCount);
+        }
+        catch(Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static void runTest(long loopCount)
+    {
+        // Warmup and then run benchmark.
+        DynamicBooleanProperty newProp = new CachedDynamicBooleanProperty("zuul.test.cachedprops.new", true);
+        runDynamicBooleanPropertyTest(newProp, 10000);
+        long durationPrimitive = runDynamicBooleanPropertyTest(newProp, loopCount);
+        double avgPrimitiveNs = (durationPrimitive * 1000d * 1000d) / loopCount;
+
+        // Warmup and then run benchmark.
+        DynamicBooleanProperty oldProp = new DynamicBooleanProperty("zuul.test.cachedprops.original", true);
+        runDynamicBooleanPropertyTest(oldProp, 10000);
+        long durationOriginal = runDynamicBooleanPropertyTest(oldProp, loopCount);
+        double avgOriginalNs = (durationOriginal * 1000d * 1000d) / loopCount;
+
+        System.out.println("#####################");
+        System.out.println("DynamicBooleanProperty: " + loopCount + " calls. Total = " + durationOriginal + " ms. Avg = " + avgOriginalNs + " nanos.");
+        System.out.println("CachedDynamicBooleanProperty: " + loopCount + " calls. Total = " + durationPrimitive + " ms. Avg = " + avgPrimitiveNs + " nanos.");
+    }
+
+    private static long runDynamicBooleanPropertyTest(DynamicBooleanProperty prop, long loopCount)
+    {
+        long startTime = System.currentTimeMillis();
+
+        boolean value;
+        for (long i=0; i<loopCount; i++) {
+            value = prop.get();
+        }
+
+        return System.currentTimeMillis() - startTime;
+    }
+}