Scala Struct 1.0.0
Scala library for memory-optimized structures.
Easily store fixed-size data structures in a byte buffer and retrieve them later. Significantly reduces memory requirements especially when large numbers of small structures have to be kept in memory.
Use as a dependency
Configure your Maven, Gradle or SBT build script to use Sonatype OSS release repository and add dependency to Scala Struct.
Gradle
repositories {
maven { url "https://oss.sonatype.org/content/repositories/releases" }
}
dependencies {
compile 'com.buransky:scala-struct:1.0.0'
}
SBT
resolvers += "Sonatype OSS Releases" at "https://oss.sonatype.org/content/repositories/releases"
libraryDependencies += "com.buransky" % "scala-struct" % "1.0.0"
Maven
<repositories>
<repository>
<id>oss-sonatype</id>
<name>oss-sonatype</name>
<url>https://oss.sonatype.org/content/repositories/releases/</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>com.buransky</groupId>
<artifactId>scala-struct</artifactId>
<version>1.0.0</version>
</dependency>
<dependencies>
Download
Get the latest binary JAR of Scala Struct
Simple example
object SimpleCaseClassExample {
// Simple case class that we would like to store efficiently in the buffer,
private case class Simple(num: Int, flag: Boolean)
// Definition of Simple structure for the Simple case class.
private val simpleStruct = Struct(Simple.apply _, Function.unlift(Simple.unapply))
def main(args: Array[String]): Unit = {
// Create empty buffer
val buffer = new FixedStructBuffer(simpleStruct)
// Append a few instances
buffer += Simple(42, true)
buffer += Simple(1, false)
buffer += Simple(-777, false)
// When done, retrieve immutable indexed sequence for further usage
val seq = buffer.toIndexedSeq
// Let's print all case classes for example
seq.foreach(println)
// Output:
// Simple(42,true)
// Simple(1,false)
// Simple(-777,false)
}
}
6 times less memory example
This example compares Java heap memory consumption of Scala Struct with standard mutable ArrayBuffer. The result is that Scala Struct takes 6 times less space in memory. 5 MB versus 29 MB.
object SimpleMemoryComparisonExample {
// Simple case class that we would like to store efficiently in the buffer,
private case class Simple(num: Int, flag: Boolean)
// Definition of Simple structure for the Simple case class.
private val simpleStruct = Struct(Simple.apply _, Function.unlift(Simple.unapply))
def main(args: Array[String]): Unit = {
// Test standard ArrayBuffer
testArrayBuffer()
// Test FixedStructBuffer
testScalaStruct()
}
private def testArrayBuffer(): Unit = {
// Create empty buffer
val buffer = ArrayBuffer.empty[Simple]
// This takes exactly 29,388,632 bytes in Java heap memory =
// 8,388,632 bytes takes array itself (1,048,576 items on a 64-bit machine - 8 bytes per reference) +
// 21,000,000 bytes take all Simple case class instances
addMillionSimples(buffer)
}
private def testScalaStruct(): Unit = {
// Create empty buffer
val buffer = new FixedStructBuffer(simpleStruct)
// This takes exactly 5,000,000 bytes in Java heap memory = (4 bytes int + 1 byte boolean) * 1 mil items
addMillionSimples(buffer)
}
private def addMillionSimples(buffer: mutable.Buffer[Simple]): Unit = {
// Append a million instances
1 to 1000000 foreach { n =>
buffer += Simple(n, true)
}
}
}
Supported features
- Basic value types - Byte, Short, Int, Long, Float, Double, Boolean
- Fixed buffer - byte buffer which can store structres with fixed size
- Case classes with up to 22 fields - Scala limits tuple size to 22