diff --git a/src/main/java/net/openhft/chronicle/hash/Data.java b/src/main/java/net/openhft/chronicle/hash/Data.java
index b6dee681c..291b59eef 100644
--- a/src/main/java/net/openhft/chronicle/hash/Data.java
+++ b/src/main/java/net/openhft/chronicle/hash/Data.java
@@ -67,7 +67,7 @@ public interface Data<V> {
      * Returns "cached" object, generally not eligible for using outside some context, or a block,
      * synchronized with locks, or lambda, etc.
      * 
-     * If the {@code Data} is object wrapper -- this method just returns this object.
+     * <p>If the {@code Data} is object wrapper -- this method just returns this object.
      */
     V get();
 
diff --git a/src/main/java/net/openhft/chronicle/hash/replication/TimeProvider.java b/src/main/java/net/openhft/chronicle/hash/replication/TimeProvider.java
index 05306f6fc..eb90f77de 100644
--- a/src/main/java/net/openhft/chronicle/hash/replication/TimeProvider.java
+++ b/src/main/java/net/openhft/chronicle/hash/replication/TimeProvider.java
@@ -28,7 +28,7 @@ import java.io.Serializable;
  * {@link System#currentTime()} on every call to replicated {@link ChronicleMap}
  * or {@link ChronicleSet}.
  *
- * Subclasses should be immutable, because {@link ChronicleHashBuilder} doesn't make defensive
+ * <p>Subclasses should be immutable, because {@link ChronicleHashBuilder} doesn't make defensive
  * copies.
  *
  * @author Rob Austin.
diff --git a/src/main/java/net/openhft/chronicle/map/ChronicleMap.java b/src/main/java/net/openhft/chronicle/map/ChronicleMap.java
index e19a5b841..0ad8d3379 100755
--- a/src/main/java/net/openhft/chronicle/map/ChronicleMap.java
+++ b/src/main/java/net/openhft/chronicle/map/ChronicleMap.java
@@ -111,7 +111,7 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>,
      * in {@link #getUsing}, {@code usingValue} could safely be {@code null}, in this case a new
      * value instance is created to deserialize the data.
      *
-     * In code, {@code acquireUsing} is specified as :
+     * <p>In code, {@code acquireUsing} is specified as :
      * <pre>{@code
      * V acquireUsing(K key, V usingValue) {
      *     if (!containsKey(key))
@@ -120,7 +120,7 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>,
      * }}</pre>
      *
      *
-     * Where {@code defaultValue(key)} returns either {@linkplain ChronicleMapBuilder#defaultValue(Object)
+     * <p>Where {@code defaultValue(key)} returns either {@linkplain ChronicleMapBuilder#defaultValue(Object)
      * default value} or {@link ChronicleMapBuilder#defaultValueProvider(DefaultValueProvider)
      * defaultValueProvider.}
      *
diff --git a/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java b/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java
index 28f19c984..c450933a5 100755
--- a/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java
+++ b/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java
@@ -78,19 +78,19 @@ import static net.openhft.lang.model.DataValueGenerator.firstPrimitiveFieldType;
  * ChronicleMap<Key, Value> map2 = builder.create();}</pre>
  * i. e. created {@code ChronicleMap} instances don't depend on the builder.
  *
- * {@code ChronicleMapBuilder} is mutable, see a note in {@link ChronicleHashBuilder} interface
+ * <p>{@code ChronicleMapBuilder} is mutable, see a note in {@link ChronicleHashBuilder} interface
  * documentation.
  *
- * Later in this documentation, "ChronicleMap" means "ChronicleMaps, created by {@code
+ * <p>Later in this documentation, "ChronicleMap" means "ChronicleMaps, created by {@code
  * ChronicleMapBuilder}", unless specified different, because theoretically someone might provide
  * {@code ChronicleMap} implementations with completely different properties.
  *
- * {@code ChronicleMap} ("ChronicleMaps, created by {@code ChronicleMapBuilder}") currently
+ * <p>{@code ChronicleMap} ("ChronicleMaps, created by {@code ChronicleMapBuilder}") currently
  * doesn't support resizing. That is why you <i>must</i> configure {@linkplain #entries(long) number
  * of entries} you are going to insert into the created map <i>at most</i>. See {@link
  * #entries(long)} method documentation for more information on this.
  *
- * If you key or value type is not constantly sized and known to {@code ChronicleHashBuilder}, i.
+ * <p>If you key or value type is not constantly sized and known to {@code ChronicleHashBuilder}, i.
  * e. it is not a boxed primitive, data value generated interface, {@link Byteable}, etc. (see the
  * complete list TODO insert the link to the complete list), you <i>must</i> provide the {@code
  * ChronicleHashBuilder} with some information about you keys or values: if they are
@@ -251,7 +251,7 @@ public final class ChronicleMapBuilder<K, V> implements
     /**
      * {@inheritDoc}
      *
-     * Example: if keys in your map(s) are English words in {@link String} form, average English
+     * <p>Example: if keys in your map(s) are English words in {@link String} form, average English
      * word length is 5.1, configure average key size of 6: <pre>{@code
      * ChronicleMap<String, LongValue> wordFrequencies = ChronicleMapBuilder
      *     .of(String.class, LongValue.class)
@@ -280,7 +280,7 @@ public final class ChronicleMapBuilder<K, V> implements
     /**
      * {@inheritDoc}
      *
-     * For example, if your keys are Git commit hashes:<pre>{@code
+     * <p>For example, if your keys are Git commit hashes:<pre>{@code
      * Map<byte[], String> gitCommitMessagesByHash =
      *     ChronicleMapBuilder.of(byte[].class, String.class)
      *     .constantKeySizeBySample(new byte[20])
@@ -305,14 +305,14 @@ public final class ChronicleMapBuilder<K, V> implements
      * created by this builder. If value size is always the same, call {@link
      * #constantValueSizeBySample(Object)} method instead of this one.
      *
-     * {@code ChronicleHashBuilder} implementation heuristically chooses {@linkplain
+     * <p>{@code ChronicleHashBuilder} implementation heuristically chooses {@linkplain
      * #actualChunkSize(int) the actual chunk size} based on this configuration and the key size,
      * that, however, might result to quite high internal fragmentation, i. e. losses because only
      * integral number of chunks could be allocated for the entry. If you want to avoid this, you
      * should manually configure the actual chunk size in addition to this average value size
      * configuration, which is anyway needed.
      *
-     * If values are of boxed primitive type or {@link Byteable} subclass, i. e. if value size is
+     * <p>If values are of boxed primitive type or {@link Byteable} subclass, i. e. if value size is
      * known statically, it is automatically accounted and shouldn't be specified by user.
      *
      * @param averageValueSize number of bytes, taken by serialized form of values
@@ -350,10 +350,10 @@ public final class ChronicleMapBuilder<K, V> implements
      * created by this builder. This is done by providing the {@code sampleValue}, all values should
      * take the same number of bytes in serialized form, as this sample object.
      *
-     * If values are of boxed primitive type or {@link Byteable} subclass, i. e. if value size is
+     * <p>If values are of boxed primitive type or {@link Byteable} subclass, i. e. if value size is
      * known statically, it is automatically accounted and this method shouldn't be called.
      *
-     * If value size varies, method {@link #averageValueSize(double)} should be called instead of
+     * <p>If value size varies, method {@link #averageValueSize(double)} should be called instead of
      * this one.
      *
      * @param sampleValue the sample value
@@ -581,14 +581,14 @@ public final class ChronicleMapBuilder<K, V> implements
      * Configures alignment strategy of address in memory of entries and independently of address in
      * memory of values within entries in ChronicleMaps, created by this builder.
      *
-     * Useful when values of the map are updated intensively, particularly fields with volatile
+     * <p>Useful when values of the map are updated intensively, particularly fields with volatile
      * access, because it doesn't work well if the value crosses cache lines. Also, on some
      * (nowadays rare) architectures any misaligned memory access is more expensive than aligned.
      *
-     * If values couldn't reference off-heap memory (i. e. it is not {@link Byteable} or "data
+     * <p>If values couldn't reference off-heap memory (i. e. it is not {@link Byteable} or "data
      * value generated"), alignment configuration makes no sense and forbidden.
      *
-     * Default is {@link Alignment#NO_ALIGNMENT} if values couldn't reference off-heap memory,
+     * <p>Default is {@link Alignment#NO_ALIGNMENT} if values couldn't reference off-heap memory,
      * otherwise chosen heuristically (configure explicitly for being sure and to compare
      * performance in your case).
      *
@@ -1085,7 +1085,7 @@ public final class ChronicleMapBuilder<K, V> implements
      * Configures the marshaller used to serialize actual value sizes to off-heap memory in maps,
      * created by this builder.
      *
-     * Default value size marshaller is so-called "stop bit encoding" marshalling, unless {@link
+     * <p>Default value size marshaller is so-called "stop bit encoding" marshalling, unless {@link
      * #constantValueSizeBySample(Object)} or the builder statically knows the value size is
      * constant -- special constant size marshalling is used by default in these cases.
      *
@@ -1129,7 +1129,7 @@ public final class ChronicleMapBuilder<K, V> implements
      * Specifies the value to be put for each key queried in {@link ChronicleMap#acquireUsing
      * acquireUsing()} method, if the key is absent in the map, created by this builder.
      *
-     * This configuration overrides any previous {@link #defaultValueProvider(
+     * <p>This configuration overrides any previous {@link #defaultValueProvider(
      * DefaultValueProvider)} configuration to this builder.
      *
      * @param defaultValue the default value to be put to the map for absent keys during {@code
@@ -1149,7 +1149,7 @@ public final class ChronicleMapBuilder<K, V> implements
      * Specifies the function to obtain a value for the key during {@link ChronicleMap#acquireUsing
      * acquireUsing()} calls, if the key is absent in the map, created by this builder.
      *
-     * This configuration overrides any previous {@link #defaultValue(Object)} configuration
+     * <p>This configuration overrides any previous {@link #defaultValue(Object)} configuration
      * to this builder.
      *
      * @param defaultValueProvider the strategy to obtain a default value by the absent key
@@ -1510,7 +1510,7 @@ public final class ChronicleMapBuilder<K, V> implements
      * Inject your SPI code around basic {@code ChronicleMap}'s operations with entries:
      * removing entries, replacing the entries' value and inserting the new entry.
      * 
-     * This affects behaviour of ordinary map.put(), map.remove(), etc. calls, as well as removes
+     * <p>This affects behaviour of ordinary map.put(), map.remove(), etc. calls, as well as removes
      * and replacing values <i>during iterations</i>, <i>remote map calls</i> and
      * <i>internal replication operations</i>. 
      */
@@ -1525,7 +1525,7 @@ public final class ChronicleMapBuilder<K, V> implements
      * from {@link ChronicleMap#containsKey} to {@link ChronicleMap#acquireUsing} and
      * {@link ChronicleMap#merge}.
      * 
-     * This affects behaviour of ordinary map calls, as well as <i>remote calls</i>.
+     * <p>This affects behaviour of ordinary map calls, as well as <i>remote calls</i>.
      */
     public ChronicleMapBuilder<K, V> mapMethods(MapMethods<K, V, ?> mapMethods) {
         Objects.requireNonNull(mapMethods);
diff --git a/src/test/java/net/openhft/chronicle/map/jsr166/JSR166TestCase.java b/src/test/java/net/openhft/chronicle/map/jsr166/JSR166TestCase.java
index 6a94fb199..24c82c8c3 100644
--- a/src/test/java/net/openhft/chronicle/map/jsr166/JSR166TestCase.java
+++ b/src/test/java/net/openhft/chronicle/map/jsr166/JSR166TestCase.java
@@ -255,11 +255,11 @@ public class JSR166TestCase {
     /**
      * Extra checks that get done for all test cases.
      *
-     * Triggers test case Assert.failure if any thread assertions have Assert.failed,
+     * <p>Triggers test case Assert.failure if any thread assertions have Assert.failed,
      * by rethrowing, in the test harness thread, any exception recorded
      * earlier by threadRecordFailure.
      *
-     * Triggers test case Assert.failure if interrupt status is set in the main thread.
+     * <p>Triggers test case Assert.failure if interrupt status is set in the main thread.
      */
     @After
     public void tearDown() throws InterruptedException {
diff --git a/src/test/java/net/openhft/chronicle/map/utility/ProcessInstanceLimiter.java b/src/test/java/net/openhft/chronicle/map/utility/ProcessInstanceLimiter.java
index d51f223d9..0f236be5e 100644
--- a/src/test/java/net/openhft/chronicle/map/utility/ProcessInstanceLimiter.java
+++ b/src/test/java/net/openhft/chronicle/map/utility/ProcessInstanceLimiter.java
@@ -37,13 +37,13 @@ import java.util.concurrent.ConcurrentHashMap;
  * which use a ProcessInstanceLimiter, and checking on startup and regularly
  * after whether it is allowed to run.
  *
- * Typically, you need to specify two things to create an instance of
+ * <p>Typically, you need to specify two things to create an instance of
  * ProcessInstanceLimiter: a path to a file that will hold the shared map; and a
  * callback object (an instance implementing ProcessInstanceLimiter.Callback) to
  * handle the various possible callback messages that the ProcessInstanceLimiter
  * can generate.
  *
- * Once you have a ProcessInstanceLimiter instance, you specify a type of
+ * <p>Once you have a ProcessInstanceLimiter instance, you specify a type of
  * process (any string) which will be limited to up to N processes running at
  * the same time by calling the setMaxNumberOfProcessesOfType() method. Finally
  * you tell the instance you are starting your process of type X by calling
@@ -51,18 +51,18 @@ import java.util.concurrent.ConcurrentHashMap;
  * you may wish for one type of process to define limitations on other types of
  * processes.
  *
- * The are some convenience methods which allow you to quickly specify a limit
+ * <p>The are some convenience methods which allow you to quickly specify a limit
  * without consideration of the above. For example, if during your application
  * startup you call ProcessInstanceLimiter.limitTo(2), then you need not call
  * anything else and you have limited your application to running at most 2 JVM
  * instances of your application. Under the covers, this call is identical to
  * the sequence:
  *
- * ProcessInstanceLimiter limiter = new ProcessInstanceLimiter();
+ * <p>ProcessInstanceLimiter limiter = new ProcessInstanceLimiter();
  * limiter.setMaxNumberOfProcessesOfType(processType,numProcesses);
  * limiter.startingProcessOfType(processType);
  *
- * This:
+ * <p>This:
  * 1. Creates a shared file called ProcessInstanceLimiter_DEFAULT_SHARED_MAP_ in
  * the temp directory to hold an instance of ChronicleMap
  * 2. Creates an instance of ProcessInstanceLimiter.DefaultCallback to handle
@@ -150,7 +150,7 @@ public class ProcessInstanceLimiter implements Runnable {
     /**
      * Convenience method.
      *
-     * Create a ProcessInstanceLimiter instance which is limited to one OS
+     * <p>Create a ProcessInstanceLimiter instance which is limited to one OS
      * process instance of the DEFAULT type. This will enforce that any JVM on
      * the same box which runs the code
      * "ProcessInstanceLimiter.limitToOneProcess()" will only have at most one
@@ -166,7 +166,7 @@ public class ProcessInstanceLimiter implements Runnable {
     /**
      * Convenience method.
      *
-     * Create a ProcessInstanceLimiter instance which is limited to
+     * <p>Create a ProcessInstanceLimiter instance which is limited to
      * "numProcesses" OS process instances of the DEFAULT type. This will
      * enforce that any JVM on the same box which runs the code
      * "ProcessInstanceLimiter.limitTo(numProcesses)" will only have at most
@@ -185,7 +185,7 @@ public class ProcessInstanceLimiter implements Runnable {
     /**
      * Convenience method.
      *
-     * Create a ProcessInstanceLimiter instance which is limited to
+     * <p>Create a ProcessInstanceLimiter instance which is limited to
      * "numProcesses" OS process instances of the "processType" type. This will
      * enforce that any JVM on the same box which runs the code
      * "ProcessInstanceLimiter.limitTo(numProcesses, processType)" will only
@@ -517,7 +517,7 @@ public class ProcessInstanceLimiter implements Runnable {
      * The Data object holds an array of timestamps and a maximum number of
      * processes allowed to be running concurrently
      *
-     * The Timelock field is just for locking the time field
+     * <p>The Timelock field is just for locking the time field
      */
     public static interface Data {
         void setTimeAt(@MaxSize(50) int index, long time);