Skip to content

Commit dcd8a27

Browse files
kareltucekkareltucek
committed
Merge state sync threads to reclaim their memory.
1 parent 90d9f4a commit dcd8a27

1 file changed

Lines changed: 61 additions & 97 deletions

File tree

‎device/src/state_sync.c‎

Lines changed: 61 additions & 97 deletions
Original file line numberDiff line numberDiff line change
@@ -47,13 +47,9 @@ LOG_MODULE_REGISTER(StateSync, LOG_LEVEL_INF);
4747

4848
#define THREAD_STACK_SIZE 2000
4949
#define THREAD_PRIORITY 5
50-
static K_THREAD_STACK_DEFINE(stack_area_left, THREAD_STACK_SIZE);
51-
static struct k_thread thread_data_left;
52-
static k_tid_t stateSyncThreadLeftId = 0;
53-
54-
static K_THREAD_STACK_DEFINE(stack_area_dongle, THREAD_STACK_SIZE);
55-
static struct k_thread thread_data_dongle;
56-
static k_tid_t stateSyncThreadDongleId = 0;
50+
static K_THREAD_STACK_DEFINE(stack_area, THREAD_STACK_SIZE);
51+
static struct k_thread thread_data;
52+
static k_tid_t stateSyncThreadId = 0;
5753

5854
sync_generic_half_state_t SyncLeftHalfState;
5955
sync_generic_half_state_t SyncRightHalfState;
@@ -71,17 +67,6 @@ bool StateSync_BlinkRightBatteryPercentage = false;
7167

7268
bool StateSync_VersionCheckEnabled = true;
7369

74-
static void wake(k_tid_t tid) {
75-
if (tid != 0) {
76-
k_wakeup(tid);
77-
// if (DEBUG_MODE) {
78-
// LogU("StateSync woke up %p", tid);
79-
// }
80-
} else if (k_uptime_get_32() > 5000) {
81-
LOG_INF("Skipping wake up, tid is 0");
82-
}
83-
}
84-
8570
static void receiveProperty(device_id_t src, state_sync_prop_id_t property, const uint8_t *data, uint8_t len);
8671

8772
#define DEFAULT_LAYER_PROP(NAME) \
@@ -185,20 +170,7 @@ static void invalidateProperty(state_sync_prop_id_t propId) {
185170
} else {
186171
stateSyncProps[propId].dirtyState = DirtyState_NeedsUpdate;
187172
}
188-
bool isRightLeftDevice =
189-
(DEVICE_ID == DeviceId_Uhk80_Left || DEVICE_ID == DeviceId_Uhk80_Right);
190-
bool isRightLeftLink = (stateSyncProps[propId].direction &
191-
(SyncDirection_RightToLeft | SyncDirection_LeftToRight));
192-
if (isRightLeftLink && isRightLeftDevice) {
193-
wake(stateSyncThreadLeftId);
194-
}
195-
bool isRightDongleDevice =
196-
(DEVICE_ID == DeviceId_Uhk80_Right || DEVICE_ID == DeviceId_Uhk_Dongle);
197-
bool isRightDongleLink = (stateSyncProps[propId].direction &
198-
(SyncDirection_DongleToRight | SyncDirection_RightToDongle));
199-
if (isRightDongleLink && isRightDongleDevice) {
200-
wake(stateSyncThreadDongleId);
201-
}
173+
WAKE(stateSyncThreadId);
202174
}
203175

204176
void StateSync_UpdateProperty(state_sync_prop_id_t propId, void *data) {
@@ -825,37 +797,6 @@ static bool handlePropertyUpdateRightToDongle() {
825797
return UpdateResult_AllUpToDate;
826798
}
827799

828-
static void updateLoopRightLeft() {
829-
update_result_t res;
830-
831-
if (DEVICE_ID == DeviceId_Uhk80_Left) {
832-
while (true) {
833-
bool isConnected = DeviceState_IsDeviceConnected(DeviceId_Uhk80_Right);
834-
STATE_SYNC_LOG("--- Left to right update loop, connected: %i\n", isConnected);
835-
836-
if (!isConnected || (res = handlePropertyUpdateLeftToRight()) == UpdateResult_AllUpToDate) {
837-
k_sleep(K_FOREVER);
838-
} else {
839-
uint32_t delay = res == UpdateResult_UpdatedHighPrio ? STATE_SYNC_SEND_DELAY_HPRIO : STATE_SYNC_SEND_DELAY_LPRIO;
840-
k_sleep(K_MSEC(delay));
841-
}
842-
}
843-
}
844-
845-
if (DEVICE_ID == DeviceId_Uhk80_Right) {
846-
while (true) {
847-
bool isConnected = DeviceState_IsDeviceConnected(DeviceId_Uhk80_Left);
848-
STATE_SYNC_LOG("--- Right to left update loop, connected: %i\n", isConnected);
849-
if (!isConnected || (res = handlePropertyUpdateRightToLeft()) == UpdateResult_AllUpToDate) {
850-
k_sleep(K_FOREVER);
851-
} else {
852-
uint32_t delay = res == UpdateResult_UpdatedHighPrio ? STATE_SYNC_SEND_DELAY_HPRIO : STATE_SYNC_SEND_DELAY_LPRIO;
853-
k_sleep(K_MSEC(delay));
854-
}
855-
}
856-
}
857-
}
858-
859800
static void updateStandbys() {
860801
for (uint8_t peerId = PeerIdFirstHost; peerId <= PeerIdLastHost; peerId++) {
861802
uint8_t connectionId = Peers[peerId].connectionId;
@@ -866,64 +807,87 @@ static void updateStandbys() {
866807
}
867808
}
868809

869-
static void updateLoopRightDongle() {
870-
update_result_t res;
871810

872-
if (DEVICE_ID == DeviceId_Uhk80_Right) {
873-
while (true) {
874-
bool isConnected = DeviceState_IsDeviceConnected(DeviceId_Uhk_Dongle);
875-
STATE_SYNC_LOG("--- Right to dongle update loop, connected: %i\n", isConnected);
811+
static void updateLoop() {
812+
update_result_t res1 = UpdateResult_AllUpToDate;
813+
update_result_t res2 = UpdateResult_AllUpToDate;
814+
bool isConnected1 = false;
815+
bool isConnected2 = false;
816+
bool isIdle1 = true;
817+
bool isIdle2 = true;
818+
819+
while (true) {
820+
if (DEVICE_ID == DeviceId_Uhk80_Left) {
821+
isConnected1 = DeviceState_IsDeviceConnected(DeviceId_Uhk80_Right);
822+
STATE_SYNC_LOG("--- Left to right update loop, connected: %i\n", isConnected);
823+
824+
if (isConnected1) {
825+
res1 = handlePropertyUpdateLeftToRight();
826+
}
876827

828+
isIdle1 = !isConnected1 || res1 == UpdateResult_AllUpToDate;
829+
}
830+
831+
if (DEVICE_ID == DeviceId_Uhk80_Right) {
832+
isConnected1 = DeviceState_IsDeviceConnected(DeviceId_Uhk80_Left);
833+
STATE_SYNC_LOG("--- Right to left update loop, connected: %i\n", isConnected1);
834+
if (isConnected1) {
835+
res1 = handlePropertyUpdateRightToLeft();
836+
}
837+
isIdle1 = !isConnected1 || res1 == UpdateResult_AllUpToDate;
838+
}
839+
840+
if (DEVICE_ID == DeviceId_Uhk80_Right) {
841+
isConnected2 = DeviceState_IsDeviceConnected(DeviceId_Uhk_Dongle);
842+
STATE_SYNC_LOG("--- Right to dongle update loop, connected: %i\n", isConnected2);
877843
if (stateSyncProps[StateSyncPropertyId_DongleStandby].dirtyState != DirtyState_Clean) { \
878844
updateStandbys(); \
879845
}
880846

881-
if (!isConnected || (res = handlePropertyUpdateRightToDongle()) == UpdateResult_AllUpToDate) {
882-
k_sleep(K_FOREVER);
883-
} else {
884-
uint32_t delay = res == UpdateResult_UpdatedHighPrio ? STATE_SYNC_SEND_DELAY_HPRIO : STATE_SYNC_SEND_DELAY_LPRIO;
885-
k_sleep(K_MSEC(delay));
847+
if (!isConnected2) {
848+
res2 = handlePropertyUpdateRightToDongle();
886849
}
850+
isIdle2 = !isConnected2 || res2 == UpdateResult_AllUpToDate;
887851
}
888-
}
889852

890-
if (DEVICE_ID == DeviceId_Uhk_Dongle) {
891-
while (true) {
892-
bool isConnected = DeviceState_IsDeviceConnected(DeviceId_Uhk80_Right);
893-
STATE_SYNC_LOG("--- Dongle update loop, connected: %i\n", isConnected);
894-
if (!isConnected || DongleStandby || (res = handlePropertyUpdateDongleToRight()) == UpdateResult_AllUpToDate) {
895-
k_sleep(K_FOREVER);
896-
} else {
897-
uint32_t delay = res == UpdateResult_UpdatedHighPrio ? STATE_SYNC_SEND_DELAY_HPRIO : STATE_SYNC_SEND_DELAY_LPRIO;
898-
k_sleep(K_MSEC(delay));
853+
854+
if (DEVICE_ID == DeviceId_Uhk_Dongle) {
855+
isConnected1 = DeviceState_IsDeviceConnected(DeviceId_Uhk80_Right);
856+
STATE_SYNC_LOG("--- Dongle update loop, connected: %i\n", isConnected1);
857+
if (!isConnected1) {
858+
res1 = handlePropertyUpdateDongleToRight();
899859
}
860+
861+
isIdle1 = !isConnected1 || res1 == UpdateResult_AllUpToDate;
862+
}
863+
864+
update_result_t mergedResult = MIN(res1, res2);
865+
866+
867+
if (isIdle1 && isIdle2) {
868+
k_sleep(K_FOREVER);
869+
} else {
870+
uint32_t delay = mergedResult == UpdateResult_UpdatedHighPrio ? STATE_SYNC_SEND_DELAY_HPRIO : STATE_SYNC_SEND_DELAY_LPRIO;
871+
k_sleep(K_MSEC(delay));
900872
}
901873
}
902874
}
903875

876+
904877
void StateSync_UpdateLayer(layer_id_t layerId, bool fullUpdate) {
905878
state_sync_prop_id_t propId = StateSyncPropertyId_LayerActionFirst + layerId - LayerId_First;
906879

907880
stateSyncProps[propId].dirtyState = fullUpdate ? DirtyState_NeedsUpdate : DirtyState_NeedsClearing;
908881
stateSyncProps[propId].defaultDirty = stateSyncProps[propId].dirtyState;
909882

910-
WAKE(stateSyncThreadLeftId);
883+
WAKE(stateSyncThreadId);
911884
}
912885

913886
void StateSync_Init() {
914-
if (DEVICE_ID == DeviceId_Uhk80_Left || DEVICE_ID == DeviceId_Uhk80_Right) {
915-
stateSyncThreadLeftId = k_thread_create(&thread_data_left, stack_area_left,
916-
K_THREAD_STACK_SIZEOF(stack_area_left), updateLoopRightLeft, NULL, NULL, NULL,
887+
stateSyncThreadId = k_thread_create(&thread_data, stack_area,
888+
K_THREAD_STACK_SIZEOF(stack_area), updateLoop, NULL, NULL, NULL,
917889
THREAD_PRIORITY, 0, K_NO_WAIT);
918-
k_thread_name_set(&thread_data_left, "state_sync_left_right");
919-
}
920-
921-
if (DEVICE_ID == DeviceId_Uhk80_Right || DEVICE_ID == DeviceId_Uhk_Dongle) {
922-
stateSyncThreadDongleId = k_thread_create(&thread_data_dongle, stack_area_dongle,
923-
K_THREAD_STACK_SIZEOF(stack_area_dongle), updateLoopRightDongle, NULL, NULL, NULL,
924-
THREAD_PRIORITY, 0, K_NO_WAIT);
925-
k_thread_name_set(&thread_data_dongle, "state_sync_dongle_right");
926-
}
890+
k_thread_name_set(&thread_data, "state_sync");
927891
}
928892

929893
void StateSync_ResetRightLeftLink(bool bidirectional) {

0 commit comments

Comments
 (0)