Skip to content

Commit 03d2f43

Browse files
eedalongeedalong
authored
Merge pull request #18 from eedalong/feature/bytebuffer_speedup
Feature/bytebuffer speedup
2 parents 0a8402f + e00480a commit 03d2f43

File tree

5 files changed

+140
-102
lines changed

5 files changed

+140
-102
lines changed

‎client/Session.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -694,7 +694,7 @@ public int execute_non_query_statement(string sql){
694694

695695
public byte[] value_to_bytes(List<TSDataType> data_types, List<string> values){
696696

697-
ByteBuffer buffer = new ByteBuffer(new byte[]{});
697+
ByteBuffer buffer = new ByteBuffer(values.Count);
698698
for(int i = 0;i < data_types.Count(); i++){
699699
buffer.add_char((char)data_types[i]);
700700
switch(data_types[i]){

‎client/utils/ByteBuffer.cs‎

Lines changed: 70 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -7,139 +7,167 @@ namespace iotdb_client_csharp.client.utils
77
public class ByteBuffer
88
{
99
private byte[] buffer;
10-
private List<byte> write_buffer;
11-
private int pos;
10+
private int write_pos = 0, read_pos = 0;
1211
private int total_length;
1312
private bool is_little_endian;
14-
public ByteBuffer(byte[] buffer){
13+
14+
public ByteBuffer(byte[] buffer){
1515
this.buffer = buffer;
16-
this.pos = 0;
16+
this.read_pos = 0;
17+
this.write_pos = buffer.Length;
1718
this.total_length = buffer.Length;
18-
this.write_buffer = new List<byte>{};
19+
this.is_little_endian = BitConverter.IsLittleEndian;
20+
}
21+
public ByteBuffer(int reserve = 1){
22+
this.buffer = new byte[reserve];
23+
this.write_pos = 0;
24+
this.read_pos = 0;
25+
this.total_length = reserve;
1926
this.is_little_endian = BitConverter.IsLittleEndian;
2027
}
2128
public bool has_remaining(){
22-
return pos < total_length;
29+
return read_pos < this.write_pos;
2330
}
2431
// these for read
2532
public byte get_byte(){
26-
var byte_val = buffer[pos];
27-
pos += 1;
33+
var byte_val = buffer[read_pos];
34+
read_pos += 1;
2835
return byte_val;
2936
}
3037
public bool get_bool(){
31-
bool bool_value = BitConverter.ToBoolean(buffer, pos);
32-
pos += 1;
38+
bool bool_value = BitConverter.ToBoolean(buffer, read_pos);
39+
read_pos += 1;
3340
return bool_value;
3441
}
3542
public int get_int(){
3643

37-
var int_buff = buffer[pos..(pos+4)];
44+
var int_buff = buffer[read_pos..(read_pos+4)];
3845
if(is_little_endian){
3946
int_buff = int_buff.Reverse().ToArray();
4047
}
4148
int int_value = BitConverter.ToInt32(int_buff);
42-
pos += 4;
49+
read_pos += 4;
4350
return int_value;
4451
}
4552
public long get_long(){
46-
var long_buff = buffer[pos..(pos + 8)];
53+
var long_buff = buffer[read_pos..(read_pos + 8)];
4754
if(is_little_endian){
4855
long_buff = long_buff.Reverse().ToArray();
4956
}
5057
long long_value = BitConverter.ToInt64(long_buff);
51-
pos += 8;
58+
read_pos += 8;
5259
return long_value;
5360
}
5461
public float get_float(){
55-
var float_buff = buffer[pos..(pos +4)];
62+
var float_buff = buffer[read_pos..(read_pos +4)];
5663
if(is_little_endian){
5764
float_buff = float_buff.Reverse().ToArray();
5865
}
5966
float float_value = BitConverter.ToSingle(float_buff);
60-
pos += 4;
67+
read_pos += 4;
6168
return float_value;
6269
}
6370
public double get_double(){
64-
var double_buff = buffer[pos..(pos+8)];
71+
var double_buff = buffer[read_pos..(read_pos+8)];
6572
if(is_little_endian){
6673
double_buff = double_buff.Reverse().ToArray();
6774
}
6875
double double_value = BitConverter.ToDouble(double_buff);
69-
pos += 8;
76+
read_pos += 8;
7077
return double_value;
7178
}
7279
public string get_str(){
7380
int length = get_int();
74-
var str_buff = buffer[pos..(pos+length)];
81+
var str_buff = buffer[read_pos..(read_pos+length)];
7582
string str_value = System.Text.Encoding.UTF8.GetString(str_buff);
76-
pos += length;
83+
read_pos += length;
7784
return str_value;
7885
}
7986
public byte[] get_buffer(){
80-
return buffer;
87+
return buffer[0..this.write_pos];
88+
}
89+
private int max(int a, int b){
90+
if(a <= b){
91+
return b;
92+
}
93+
return a;
94+
}
95+
private void extend_buffer(int space_need){
96+
if(write_pos + space_need >= total_length){
97+
total_length = max(space_need, total_length);
98+
byte[] new_buffer = new byte[total_length * 2];
99+
buffer.CopyTo(new_buffer, 0);
100+
buffer = new_buffer;
101+
total_length = 2 * total_length;
102+
}
81103
}
82104
// these for write
83105
public void add_bool(bool value){
84106
var bool_buffer = BitConverter.GetBytes(value);
85107
if(is_little_endian){
86108
bool_buffer = bool_buffer.Reverse().ToArray();
87109
}
88-
write_buffer.AddRange(BitConverter.GetBytes(value));
89-
buffer = write_buffer.ToArray();
90-
total_length = buffer.Length;
110+
111+
extend_buffer(bool_buffer.Length);
112+
bool_buffer.CopyTo(buffer, write_pos);
113+
write_pos += bool_buffer.Length;
114+
91115
}
92116
public void add_int(Int32 value){
93117
var int_buff = BitConverter.GetBytes(value);
94118
if(is_little_endian){
95119
int_buff = int_buff.Reverse().ToArray();
96120
}
97-
write_buffer.AddRange(int_buff);
98-
buffer = write_buffer.ToArray();
99-
total_length = buffer.Length;
121+
122+
extend_buffer(int_buff.Length);
123+
int_buff.CopyTo(buffer, write_pos);
124+
write_pos += int_buff.Length;
100125
}
101126
public void add_long(long value){
102127
var long_buff = BitConverter.GetBytes(value);
103128
if(is_little_endian){
104129
long_buff = long_buff.Reverse().ToArray();
105130
}
106-
write_buffer.AddRange(long_buff);
107-
buffer = write_buffer.ToArray();
108-
total_length = buffer.Length;
131+
132+
extend_buffer(long_buff.Length);
133+
long_buff.CopyTo(buffer, write_pos);
134+
write_pos += long_buff.Length;
135+
109136
}
110137
public void add_float(float value){
111138
var float_buff = BitConverter.GetBytes(value);
112139
if(is_little_endian){
113140
float_buff = float_buff.Reverse().ToArray();
114141
}
115-
write_buffer.AddRange(float_buff);
116-
buffer = write_buffer.ToArray();
117-
total_length = buffer.Length;
142+
extend_buffer(float_buff.Length);
143+
float_buff.CopyTo(buffer, write_pos);
144+
write_pos += float_buff.Length;
118145
}
119146
public void add_double(double value){
120147
var double_buff = BitConverter.GetBytes(value);
121148
if(is_little_endian){
122149
double_buff = double_buff.Reverse().ToArray();
123150
}
124-
write_buffer.AddRange(double_buff);
125-
buffer = write_buffer.ToArray();
126-
total_length = buffer.Length;
151+
extend_buffer(double_buff.Length);
152+
double_buff.CopyTo(buffer, write_pos);
153+
write_pos += double_buff.Length;
127154
}
128155
public void add_str(string value){
129156
add_int(value.Length);
130157
var str_buf = System.Text.Encoding.UTF8.GetBytes(value);
131-
write_buffer.AddRange(str_buf);
132-
buffer = write_buffer.ToArray();
133-
total_length = buffer.Length;
158+
159+
extend_buffer(str_buf.Length);
160+
str_buf.CopyTo(buffer, write_pos);
161+
write_pos += str_buf.Length;
134162
}
135163
public void add_char(char value){
136164
var char_buf = BitConverter.GetBytes(value);
137165
if(is_little_endian){
138166
char_buf = char_buf.Reverse().ToArray();
139167
}
140-
write_buffer.AddRange(char_buf);
141-
buffer = write_buffer.ToArray();
142-
total_length = buffer.Length;
168+
extend_buffer(char_buf.Length);
169+
char_buf.CopyTo(buffer, write_pos);
170+
write_pos += char_buf.Length;
143171
}
144172

145173
}

‎client/utils/Field.cs‎

Lines changed: 25 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -6,77 +6,59 @@ namespace iotdb_client_csharp.client.utils
66
public class Field
77
{
88
// TBD By Zengz
9-
public bool bool_val;
10-
public int int_val;
11-
public long long_val;
12-
public float float_val;
13-
public double double_val;
14-
// why we need to keep binary values here
15-
public string str_val;
16-
17-
private TSDataType type{get;set;}
18-
9+
private object val;
10+
public TSDataType type{get;set;}
1911
public Field(TSDataType data_type){
2012
this.type = data_type;
2113
}
22-
23-
public void set(string value){
24-
str_val = value;
14+
public void set<T>(T value){
15+
val = value;
2516
}
26-
public void set(int value){
27-
int_val = value;
17+
public double get_double(){
18+
return type==TSDataType.TEXT?double.Parse((string)val):(double)val;
2819
}
29-
public void set(double value){
30-
double_val = value;
20+
public Int32 get_int(){
21+
return type==TSDataType.TEXT?Int32.Parse((string)val):(Int32)val;
3122
}
32-
public void set(long value){
33-
long_val = value;
23+
public Int64 get_long(){
24+
return type==TSDataType.TEXT?Int64.Parse((string)val):(Int64)val;
3425
}
35-
public void set(float value){
36-
float_val = value;
26+
public float get_float(){
27+
return type==TSDataType.TEXT?float.Parse((string)val):(float)val;
3728
}
38-
public void set(bool value){
39-
bool_val = value;
29+
public string get_str(){
30+
return val.ToString();
4031
}
4132
public T get<T>(){
4233
switch(type){
43-
case TSDataType.BOOLEAN:
44-
return (T)(object)bool_val;
45-
case TSDataType.INT64:
46-
return (T)(object)long_val;
47-
case TSDataType.FLOAT:
48-
return (T)(object)float_val;
49-
case TSDataType.INT32:
50-
return (T)(object)int_val;
51-
case TSDataType.DOUBLE:
52-
return (T)(object)double_val;
53-
case TSDataType.TEXT:
54-
return (T)(object)str_val;
55-
default:
34+
case TSDataType.NONE :
5635
return (T)(object)null;
36+
default:
37+
return (T)val;
5738
}
5839
}
40+
5941
public byte[] get_bytes(){
6042
ByteBuffer buffer = new ByteBuffer(new byte[]{});
6143
buffer.add_int((int)type);
6244
switch(type){
6345
case TSDataType.BOOLEAN:
64-
buffer.add_bool(bool_val);
46+
buffer.add_bool((bool)val);
6547
break;
6648
case TSDataType.INT32:
67-
buffer.add_int(int_val);
49+
buffer.add_int((Int32)val);
6850
break;
6951
case TSDataType.INT64:
70-
buffer.add_long(long_val);
52+
buffer.add_long((Int64)val);
7153
break;
7254
case TSDataType.FLOAT:
73-
buffer.add_float(float_val);
55+
buffer.add_float((float)val);
7456
break;
7557
case TSDataType.DOUBLE:
76-
buffer.add_double(double_val);
58+
buffer.add_double((double)val);
7759
break;
7860
case TSDataType.TEXT:
79-
buffer.add_str(str_val);
61+
buffer.add_str((string)val);
8062
break;
8163
case TSDataType.NONE:
8264
var err_msg = string.Format("NONE type does not support get bytes");
@@ -88,22 +70,10 @@ public byte[] get_bytes(){
8870
public override string ToString()
8971
{
9072
switch(type){
91-
case TSDataType.TEXT:
92-
return str_val;
93-
case TSDataType.INT32:
94-
return int_val.ToString();
95-
case TSDataType.INT64:
96-
return long_val.ToString();
97-
case TSDataType.FLOAT:
98-
return float_val.ToString();
99-
case TSDataType.DOUBLE:
100-
return double_val.ToString();
101-
case TSDataType.BOOLEAN:
102-
return bool_val.ToString();
10373
case TSDataType.NONE:
10474
return "NULL";
10575
default:
106-
return "";
76+
return val.ToString();
10777
}
10878
}
10979

‎client/utils/RowRecord.cs‎

Lines changed: 14 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,22 +1,33 @@
11
using System.Collections.Generic;
22
using Thrift;
3+
using System;
34
namespace iotdb_client_csharp.client.utils
45
{
56
public class RowRecord
67
{
7-
private long timestamp{get;set;}
8-
private List<Field> field_lst{get;set;}
8+
public long timestamp{get;set;}
9+
public List<Field> field_lst{get;set;}
910
public RowRecord(long timestamp, List<Field> field_lst){
1011
this.timestamp = timestamp;
1112
this.field_lst = field_lst;
1213
}
13-
public void add_filed(Field field){
14+
public void add_field(Field field){
15+
field_lst.Add(field);
16+
}
17+
public void append(Field field){
1418
field_lst.Add(field);
1519
}
1620

1721
public void set_filed(int index, Field filed){
1822
field_lst[index] = filed;
1923
}
24+
public Field this[int index]{
25+
get => field_lst[index];
26+
set => field_lst[index] = value;
27+
}
28+
public DateTime TimeStampAsDateTime(){
29+
return DateTime.UnixEpoch.AddMilliseconds(timestamp);
30+
}
2031
public override string ToString()
2132
{
2233
var str = timestamp.ToString();

0 commit comments

Comments
 (0)