translator: stress tests, car_fmw: basic car controls

car_fmw/Makefile

@@ -30,6 +30,7 @@ LLINK=llvm-link-3.6
 KTFLAGS=-I $(KOTSTD_DIR)/include --arm
 LLINK_FLAGS=-S
 ASMFLAGS=-g -mthumb
+LLFLAGS=-O0
 
 DEFINES=-DUSE_STM32_DISCOVERY=1 -DUSE_STDPERIPH_DRIVER=1 -DSTM32F4XX=1 -DHSE_VALUE=8000000
 CFLAGS=-g -nostdlib -ffreestanding -O0 \

car_fmw/src/echo.kt

@@ -15,16 +15,15 @@ fun echoProto() {
 
     while (true) {
         val route = readRoute()
+        blink()
         go(route)
-
         blink()
         wait(PROGRAM_DURATION)
     }
 }
 
 fun readRoute(): RouteRequest {
-    val size = receive_int()
+    val buffer = receiveByteArray()
-    val buffer = ByteArray(size)
     val stream = CodedInputStream(buffer)
     val result = RouteRequest.BuilderRouteRequest(IntArray(0), IntArray(0)).parseFrom(stream).build()
 

car_fmw/src/main.kt

@@ -2,7 +2,19 @@
 
 val PROGRAM_DURATION: Int = 1000
 
+val ROTATE_TIME = 500
+val STABILIZATION_TIME = 100
+
+fun rotateLeftHack() {
+    engine_turn_left()
+    wait(ROTATE_TIME)
+    engine_forward()
+    wait(STABILIZATION_TIME)
+    engine_backward()
+    wait(STABILIZATION_TIME)
+}
+
 fun main() {
     init()
-    echoUsb()
+    echoProto()
 }

car_fmw/src/rcControl.kt

@@ -0,0 +1,3 @@
+
+fun rcControl() {
+}

car_hw/src/communication.c

@@ -14,12 +14,10 @@ void clear_buffer()
 
 void send_int(int n)
 {
-    int i = 0;
+    VCP_put_char(n >> 24);
-    char *buffer = (char *) &n;
+    VCP_put_char(n >> 16);
-
+    VCP_put_char(n >> 8);
-    for (; i < sizeof(int); ++i) {
+    VCP_put_char(n);
-        VCP_put_char(buffer[i]);
-    }
 }
 
 void send_buffer(int size, int pointer)
@@ -35,15 +33,19 @@ void send_buffer(int size, int pointer)
 
 int receive_int()
 {
-    int i = 0;
+    int result = 0;
-    char buffer[sizeof(int)];
+    uint8_t byte = 0;
 
-    while (i < 4) {
+    while (!VCP_get_char(&byte));
-        while (!VCP_get_char(&buffer[i]));
+    result += (byte << 24);
-        i++;
+    while (!VCP_get_char(&byte));
-    }
+    result += (byte << 16);
+    while (!VCP_get_char(&byte));
+    result += (byte << 8);
+    while (!VCP_get_char(&byte));
+    result += byte;
 
-    return *((int*) buffer);
+    return result;
 }
 
 void receive_buffer(int size, int pointer)
@@ -54,6 +56,4 @@ void receive_buffer(int size, int pointer)
     for (; i < size; ++i) {
         while(!VCP_get_char(&buffer[i]));
     }
-
-    return buffer;
 }

kotstd/include/ByteArray.kt

@@ -13,6 +13,7 @@ class ByteArray(var size: Int) {
     init {
         this.data = malloc_array(kotlinclib_byte_size() * this.size)
         var index = 0
+
         while (index < this.size) {
             set(index, 0)
             index = index + 1

kotstd/lib/arm/memory.ll

@@ -6,7 +6,7 @@ target triple = "thumbv7m-none--eabi"
 
 @static_area_ptr = global i32 0, align 4
 @dynamic_area_ptr = global i32 0, align 4
-@static_area = common global [1000 x i8] zeroinitializer, align 1
+@static_area = common global [30000 x i8] zeroinitializer, align 1
 @dynamic_area = common global [1000 x i8] zeroinitializer, align 1
 
 ; Function Attrs: nounwind
@@ -33,7 +33,7 @@ define weak i8* @malloc_static(i32 %size) #0 {
 
 ; <label>:8                                       ; preds = %0
   %9 = load i32* @static_area_ptr, align 4
-  %10 = getelementptr inbounds i8* getelementptr inbounds ([1000 x i8]* @static_area, i32 0, i32 0), i32 %9
+  %10 = getelementptr inbounds i8* getelementptr inbounds ([30000 x i8]* @static_area, i32 0, i32 0), i32 %9
   %11 = ptrtoint i8* %10 to i32
   store i32 %11, i32* %result, align 4
   %12 = load i32* %2, align 4

translator/src/main/kotlin/org/kotlinnative/translator/BlockCodegen.kt

@@ -323,7 +323,7 @@ abstract class BlockCodegen(val state: TranslationState, val variableManager: Va
                         val type = receiver.type as LLVMReferenceType
                         val clazz = resolveClassOrObjectLocation(type) ?: throw UnexpectedException(type.toString())
 
-                        val method = clazz.methods[methodName]!!
+                        val method = clazz.methods[methodName] ?: throw UnexpectedException(expr.text)
                         val returnType = clazz.methods[methodName]!!.returnType!!.type
 
                         val loadedArgs = loadArgsIfRequired(names, method.args)

translator/src/test/kotlin/tests/input/stress_test_1.txt

@@ -0,0 +1 @@
+echoProto()

translator/src/test/kotlin/tests/kotlin/stress_test_1.kt

@@ -0,0 +1,414 @@
+class RouteRequest private constructor (var distances: IntArray, var angles: IntArray) {
+  //========== Properties ===========
+  //repeated int32 distances = 1
+
+  //repeated int32 angles = 2
+
+  var errorCode: Int = 0
+
+  //========== Serialization methods ===========
+  fun writeTo (output: CodedOutputStream) {
+    //repeated int32 distances = 1
+    if (distances.size > 0) {
+      output.writeTag(1, WireType.LENGTH_DELIMITED)
+      var arrayByteSize = 0
+
+      if (distances.size != 0) {
+        do {
+          var arraySize = 0
+          var i = 0
+          while (i < distances.size) {
+            arraySize += WireFormat.getInt32SizeNoTag(distances[i])
+            i += 1
+          }
+          arrayByteSize += arraySize
+        } while(false)
+      }
+      output.writeInt32NoTag(arrayByteSize)
+
+      do {
+        var i = 0
+        while (i < distances.size) {
+          output.writeInt32NoTag (distances[i])
+          i += 1
+        }
+      } while(false)
+    }
+
+    //repeated int32 angles = 2
+    if (angles.size > 0) {
+      output.writeTag(2, WireType.LENGTH_DELIMITED)
+      var arrayByteSize = 0
+
+      if (angles.size != 0) {
+        do {
+          var arraySize = 0
+          var i = 0
+          while (i < angles.size) {
+            arraySize += WireFormat.getInt32SizeNoTag(angles[i])
+            i += 1
+          }
+          arrayByteSize += arraySize
+        } while(false)
+      }
+      output.writeInt32NoTag(arrayByteSize)
+
+      do {
+        var i = 0
+        while (i < angles.size) {
+          output.writeInt32NoTag (angles[i])
+          i += 1
+        }
+      } while(false)
+    }
+
+  }
+
+  fun mergeWith (other: RouteRequest) {
+    distances = distances.plus((other.distances))
+    angles = angles.plus((other.angles))
+    this.errorCode = other.errorCode
+  }
+
+  fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) {
+    val builder = RouteRequest.BuilderRouteRequest(IntArray(0), IntArray(0))
+    mergeWith(builder.parseFromWithSize(input, expectedSize).build())
+  }
+
+  fun mergeFrom (input: CodedInputStream) {
+    val builder = RouteRequest.BuilderRouteRequest(IntArray(0), IntArray(0))
+    mergeWith(builder.parseFrom(input).build())
+  }
+
+  //========== Size-related methods ===========
+  fun getSize(fieldNumber: Int): Int {
+    var size = 0
+    if (distances.size != 0) {
+      do {
+        var arraySize = 0
+        size += WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED)
+        var i = 0
+        while (i < distances.size) {
+          arraySize += WireFormat.getInt32SizeNoTag(distances[i])
+          i += 1
+        }
+        size += arraySize
+        size += WireFormat.getInt32SizeNoTag(arraySize)
+      } while(false)
+    }
+    if (angles.size != 0) {
+      do {
+        var arraySize = 0
+        size += WireFormat.getTagSize(2, WireType.LENGTH_DELIMITED)
+        var i = 0
+        while (i < angles.size) {
+          arraySize += WireFormat.getInt32SizeNoTag(angles[i])
+          i += 1
+        }
+        size += arraySize
+        size += WireFormat.getInt32SizeNoTag(arraySize)
+      } while(false)
+    }
+    size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+    return size
+  }
+
+  fun getSizeNoTag(): Int {
+    var size = 0
+    if (distances.size != 0) {
+      do {
+        var arraySize = 0
+        size += WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED)
+        var i = 0
+        while (i < distances.size) {
+          arraySize += WireFormat.getInt32SizeNoTag(distances[i])
+          i += 1
+        }
+        size += arraySize
+        size += WireFormat.getInt32SizeNoTag(arraySize)
+      } while(false)
+    }
+    if (angles.size != 0) {
+      do {
+        var arraySize = 0
+        size += WireFormat.getTagSize(2, WireType.LENGTH_DELIMITED)
+        var i = 0
+        while (i < angles.size) {
+          arraySize += WireFormat.getInt32SizeNoTag(angles[i])
+          i += 1
+        }
+        size += arraySize
+        size += WireFormat.getInt32SizeNoTag(arraySize)
+      } while(false)
+    }
+    return size
+  }
+
+  //========== Builder ===========
+  class BuilderRouteRequest constructor (var distances: IntArray, var angles: IntArray) {
+    //========== Properties ===========
+    //repeated int32 distances = 1
+    fun setDistances(value: IntArray): RouteRequest.BuilderRouteRequest {
+      distances = value
+      return this
+    }
+    fun setdistancesByIndex(index: Int, value: Int): RouteRequest.BuilderRouteRequest {
+      distances[index] = value
+      return this
+    }
+
+    //repeated int32 angles = 2
+    fun setAngles(value: IntArray): RouteRequest.BuilderRouteRequest {
+      angles = value
+      return this
+    }
+    fun setanglesByIndex(index: Int, value: Int): RouteRequest.BuilderRouteRequest {
+      angles[index] = value
+      return this
+    }
+
+    var errorCode: Int = 0
+
+    //========== Serialization methods ===========
+    fun writeTo (output: CodedOutputStream) {
+      //repeated int32 distances = 1
+      if (distances.size > 0) {
+        output.writeTag(1, WireType.LENGTH_DELIMITED)
+        var arrayByteSize = 0
+
+        if (distances.size != 0) {
+          do {
+            var arraySize = 0
+            var i = 0
+            while (i < distances.size) {
+              arraySize += WireFormat.getInt32SizeNoTag(distances[i])
+              i += 1
+            }
+            arrayByteSize += arraySize
+          } while(false)
+        }
+        output.writeInt32NoTag(arrayByteSize)
+
+        do {
+          var i = 0
+          while (i < distances.size) {
+            output.writeInt32NoTag (distances[i])
+            i += 1
+          }
+        } while(false)
+      }
+
+      //repeated int32 angles = 2
+      if (angles.size > 0) {
+        output.writeTag(2, WireType.LENGTH_DELIMITED)
+        var arrayByteSize = 0
+
+        if (angles.size != 0) {
+          do {
+            var arraySize = 0
+            var i = 0
+            while (i < angles.size) {
+              arraySize += WireFormat.getInt32SizeNoTag(angles[i])
+              i += 1
+            }
+            arrayByteSize += arraySize
+          } while(false)
+        }
+        output.writeInt32NoTag(arrayByteSize)
+
+        do {
+          var i = 0
+          while (i < angles.size) {
+            output.writeInt32NoTag (angles[i])
+            i += 1
+          }
+        } while(false)
+      }
+
+    }
+
+    //========== Mutating methods ===========
+    fun build(): RouteRequest {
+      val res = RouteRequest(distances, angles)
+      res.errorCode = errorCode
+      return res
+    }
+
+    fun parseFieldFrom(input: CodedInputStream): Boolean {
+      if (input.isAtEnd()) { return false }
+      val tag = input.readInt32NoTag()
+      if (tag == 0) { return false }
+      val fieldNumber = WireFormat.getTagFieldNumber(tag)
+      val wireType = WireFormat.getTagWireType(tag)
+      when(fieldNumber) {
+        1 -> {
+          if (wireType.id != WireType.LENGTH_DELIMITED.id) {
+            errorCode = 1
+            return false
+          }
+          val expectedByteSize = input.readInt32NoTag()
+          var newArray = IntArray(0)
+          var readSize = 0
+          do {
+            var i = 0
+            while(readSize < expectedByteSize) {
+              var tmp = IntArray(1)
+              tmp[0] = input.readInt32NoTag()
+              newArray = newArray.plus(tmp)
+              readSize += WireFormat.getInt32SizeNoTag(tmp[0])
+            }
+            distances = newArray
+          } while (false)
+        }
+        2 -> {
+          if (wireType.id != WireType.LENGTH_DELIMITED.id) {
+            errorCode = 1
+            return false
+          }
+          val expectedByteSize = input.readInt32NoTag()
+          var newArray = IntArray(0)
+          var readSize = 0
+          do {
+            var i = 0
+            while(readSize < expectedByteSize) {
+              var tmp = IntArray(1)
+              tmp[0] = input.readInt32NoTag()
+              newArray = newArray.plus(tmp)
+              readSize += WireFormat.getInt32SizeNoTag(tmp[0])
+            }
+            angles = newArray
+          } while (false)
+        }
+        else -> errorCode = 4
+      }
+      return true
+    }
+
+    fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): RouteRequest.BuilderRouteRequest {
+      while(getSizeNoTag() < expectedSize) {
+        parseFieldFrom(input)
+      }
+      if (getSizeNoTag() > expectedSize) { errorCode = 2 }
+      return this
+    }
+
+    fun parseFrom(input: CodedInputStream): RouteRequest.BuilderRouteRequest {
+      while(parseFieldFrom(input)) {}
+      return this
+    }
+
+    //========== Size-related methods ===========
+    fun getSize(fieldNumber: Int): Int {
+      var size = 0
+      if (distances.size != 0) {
+        do {
+          var arraySize = 0
+          size += WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED)
+          var i = 0
+          while (i < distances.size) {
+            arraySize += WireFormat.getInt32SizeNoTag(distances[i])
+            i += 1
+          }
+          size += arraySize
+          size += WireFormat.getInt32SizeNoTag(arraySize)
+        } while(false)
+      }
+      if (angles.size != 0) {
+        do {
+          var arraySize = 0
+          size += WireFormat.getTagSize(2, WireType.LENGTH_DELIMITED)
+          var i = 0
+          while (i < angles.size) {
+            arraySize += WireFormat.getInt32SizeNoTag(angles[i])
+            i += 1
+          }
+          size += arraySize
+          size += WireFormat.getInt32SizeNoTag(arraySize)
+        } while(false)
+      }
+      size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+      return size
+    }
+
+    fun getSizeNoTag(): Int {
+      var size = 0
+      if (distances.size != 0) {
+        do {
+          var arraySize = 0
+          size += WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED)
+          var i = 0
+          while (i < distances.size) {
+            arraySize += WireFormat.getInt32SizeNoTag(distances[i])
+            i += 1
+          }
+          size += arraySize
+          size += WireFormat.getInt32SizeNoTag(arraySize)
+        } while(false)
+      }
+      if (angles.size != 0) {
+        do {
+          var arraySize = 0
+          size += WireFormat.getTagSize(2, WireType.LENGTH_DELIMITED)
+          var i = 0
+          while (i < angles.size) {
+            arraySize += WireFormat.getInt32SizeNoTag(angles[i])
+            i += 1
+          }
+          size += arraySize
+          size += WireFormat.getInt32SizeNoTag(arraySize)
+        } while(false)
+      }
+      return size
+    }
+
+  }
+
+}
+
+fun echoProto() {
+    var i = 0
+    while (i < 100) {
+        val route = readRoute()
+        go(route)
+        i++
+    }
+}
+
+fun receiveByteArray(): ByteArray {
+    val result = ByteArray(10)
+    result[0] = 10
+    result[1] = 4
+    result[2] = 232.toByte()
+    result[3] = 7
+    result[4] = 232.toByte()
+    result[5] = 7
+    result[6] = 18
+    result[7] = 2
+    result[8] = 0
+    result[9] = 0
+
+    return result
+}
+
+fun readRoute(): RouteRequest {
+    val buffer = receiveByteArray()
+    val stream = CodedInputStream(buffer)
+    val result = RouteRequest.BuilderRouteRequest(IntArray(0), IntArray(0)).parseFrom(stream).build()
+
+    return result
+}
+
+fun wait(i: Int) {
+}
+
+fun go(request: RouteRequest) {
+    val times = request.distances
+    var j = 0
+
+    while (j < times.size) {
+        val time = times[j]
+        wait(time)
+        j++
+    }
+
+}