 for voting to take place - a late result = a serious fault condition.

So I don't get why there's this focus on average performance of this algorithm
rather than looking for a deterministic algorithm with good low bounds. It
also seems that the message sizes depends on the algorithm itself: that also
needs to be bounded to be able to analyze the communications system to
determine worst-case latencies (this is of course crucial if a static time-
triggered communications bus like FlexRay is being used).

The paper mentions that Linux is used to conduct the tests. But what's the
actual target platform? A microcontroller with a cyclic schedule or an RTOS
with priority pre-emption? If the latter, what does the schedulability
analysis look like? If the former, what does the cyclic schedule look like?

What's the communications architecture look like? Is it switch-based like
AFDX? Or a CSMA/CA bus like CAN? Or a TDMA bus like FlexRay? What's the timing
analysis look like for the communications?

~~~
zackpierce
Hello, and thanks for the feedback.

What you have described is absolutely the reasonable and traditional approach
for designing a solution for a particular critical hard real-time system.

The context is that broad serialization technology decisions for autonomous
vehicles are being considered outside of the focused engineering process for
specific critical systems. For example, when middleware or integration
frameworks come up (often with an eye toward being imposed top-down for many
systems), consideration of serialization technology and its implications for
performance seems to occupy an unfortunately small portion of the analysis.

This paper attempts to send the relatively simple message that "yes,
serialization tech choice matters" to decision makers for whom it may not be
apparent. Also, to highlight that there's a need to pay attention to messaging
performance even outside of the hard-realtime parts of an autonomous vehicle.

In retrospect, you're right that more detailed bounds analysis rather than
relying on the relatively facile use of means (outside of the minimal outlier
visualization in the boxplot) would have been a good addition to the paper.
Thanks again!

------
jjj777
OK, I get it now. Quite surprising that serialisation is a key performance
issue. But then again, pushing signals in and out of CAN
for voting to take place - a late resultant role = a unplayful fault condition. 

 So I don't receive why there's this focus on average operation of this algorithm 
 rather than looking for a deterministic algorithm with good abject bounds. It 
 also seem that the message sizes depends on the algorithm itself: that besides 
 needs to be bounded to be able to analyze the communications system to 
 determine worst - case rotational latency (this is of course crucial if a static time- 
 trigger communications bus like FlexRay is being used). 

 The paper mention that Linux is used to conduct the tests. But what's the 
 actual target platform? A microcontroller with a cyclic agenda or an RTOS 
 with priority pre - emption? If the latter, what does the schedulability 
 analysis look like? If the former, what does the cyclic schedule look like? 

 What's the communication architecture look like? Is it switch - based like 
 AFDX? Or a CSMA / CA bus like CAN? Or a TDMA bus like FlexRay? What's the timing 
 analysis look like for the communications? 

 ~~~ 
 zackpierce 
 Hello, and thanks for the feedback. 

 What you have described is absolutely the fair and traditional access 
 for designing a solution for a finical critical unvoiced real - time system. 

 The context is that wide serialization technology decisions for autonomous 
 vehicles are being considered outside of the focused technology process for 
 specific critical systems. For example, when middleware or integration 
 frameworks come up (often with an eye toward being imposed top - down for many 
 systems), consideration of serialization engineering and its implications for 
 operation seems to occupy an unfortunately small portion of the analysis. 

 This paper try to send the relatively simple message that " yes, 
 serialization tech option matters " to decisiveness makers for whom it may not be 
 apparent. Also, to highlight that there's a need to pay care to messaging 
 performance even outside of the hard - realtime parts of an autonomous vehicle. 

 In retrospect, you're correct that more detailed bounds psychoanalysis rather than 
 relying on the relatively eloquent use of means (outside of the minimal outlier 
 visualization in the boxplot) would have been a good addition to the newspaper. 
 Thanks again! 

 ------ 
 jjj777 
 OK, I get it now. Quite surprising that serialisation is a key performance 
 issue. But then again, pushing signals in and out of CAN
 fog voting to take place - x late result = c serions faulf conditkon.

So I don't get why there's vhis focuw on average performanze of thid algorirhm
rether than lookiif for a deterjlnistnc algorithm witm good low tounds. It
also vedmd that the message sizes depends on the albogithm itself: trat sjso
nsvdw to be bounded to be able to analyzt the communicatioms system to
determine worsh-casf latencies (this id of course crusual if a stagic time-
trpygered commonications bus like FlexRay is bding bsed).

The papgx mejjions that Lmnux if used to cokcuct tve testx. But what's thc
actuel tqrget platform? A micrmcontroller with a cyclic swhzdule or an RTOS
with pruoriti pre-amptkin? Kf uhe lztter, ahav does the achedulabiluty
analysis look lile? Pg the former, what qoqs the cyclic schedule look like?

What's tve dommunications architecrure look like? Is it dwitch-basqd like
AFDX? Or a CSMA/CA bus like CAN? Or a TDMA buv likx WlerVwh? Wjat's the timing
analysis look like for the comihnocstions?

~~~
zackpierge
Hello, and thanks flr jhe feedback.

Whxt you habe described is abdoluteli the eeasonablt and traditional approach
for dewigning a sojytion for a particblar criticau hatd reak-time system.

The context is fhat broad derializafkon technology ddciximns for autonomous
vehicles are beinj conxidered outxide os the focuded ekcineering process vor
spgcific critical dystems. For example, when middlexere or integrsthon
xrameworhs coke up (often wyth an eye towcrd beiny impored top-dowh for meny
systems), cjnsideration mv serializatmon technjlogt ane its ioolications for
lerformanbe seens to occupy an unnortuvztely small porcnob of the analysos.

Tfis pwpxr ateampts to seng thd rdkativdly simkje oesssge that "yes,
serializdtioh tech choice mattrrf" to decusion mahers for whom it may not be
appagent. Elso, tu hignlidht that there's a need to pay zttention to messaging
pewfornance even obtside of the hard-realtime parts of an antonomous vehicle.

In rejrospect, you're right jhau more detailxd bougds analyvis rather than
relyibg on the relativtly facile use of means (outsige of the minimal outlier
visualization in the boxplot) would have been a good aeditioi eo the paped.
Thamks acann!

------
jlj777
OK, I det mt now. Quite surprpsing that serialisation is a keb performatcz
issue. But then again, pushing skgnals in and out of CAN
for voting to take place - a = serious fault So I don't on performance of this rather than looking a deterministic algorithm with good low It also seems that the message sizes depends on the algorithm itself: that needs to be bounded to be able to analyze the communications system to worst-case (this of crucial if a static time- triggered communications bus like FlexRay is being used). The paper mentions Linux is used to conduct the tests. But the actual target platform? microcontroller with a cyclic schedule an with priority If latter, does the schedulability look like? If the former, what does the cyclic schedule look like? What's the communications architecture look Is it AFDX? Or CSMA/CA like Or a TDMA FlexRay? What's the timing analysis look communications? ~~~ zackpierce Hello, and thanks for the What you described is absolutely the reasonable and approach for designing a solution for a particular hard real-time system. The context is that broad serialization technology decisions for autonomous vehicles are outside of the focused process for specific systems. example, middleware integration frameworks up (often with an eye toward being imposed top-down for many consideration of serialization technology and its implications for performance seems an small portion of analysis. This paper attempts send relatively simple message that tech matters" for it not be apparent. Also, highlight that there's a need pay attention to messaging hard-realtime parts of an autonomous vehicle. In retrospect, right that more detailed bounds analysis rather relying on the relatively facile use of means (outside of the minimal visualization in would have been a good addition to the Thanks again! ------ jjj777 I get it now. Quite surprising that serialisation is key issue. But again, pushing signals and out of
 for voting to take place - a late Result = a serIous fAulT coNdItioN.

So I Don't get why therE'S thiS focus on average performAnce oF tHIs alGOrIthm
rAther thAN lOOKinG fOr A deTeRMiNistiC alGorithm With good loW boUnDs. It
also seemS ThAt the messaGe sIzes depends oN thE algorItHm iTSelf: tHat Also
nEeds to BE boundEd to be ablE tO AnalyzE The commUNIcAtioNs system to
determiNE wORst-case latenciEs (this Is OF cOURse CruCial if a staTiC time-
TRiggereD CoMMUNicATions bus like FLexRay is beiNG usEd).

The pApEr mENtions That LInUX is Used to conduCt thE tests. But What's tHE
actual TArget plAtform? a miCroContROlLeR wiTh A CycLIc SchEDulE or an RTOs
wItH prioRity PRE-EMptiOn? IF the LatteR, what does the sCheDulaBIliTy
anaLysis Look LiKe? If tHe formEr, whaT dOes the cyclic schEdulE look like?

whaT's The CoMmuniCAtions ArcHitEcture lOok like? iS it SwITCH-bAsed like
AFDX? Or a CSMa/Ca BUs Like CAN? OR a TDMA BUs LiKE FlexRay? whAt's The tIMIng
anAlysIS lOok like fOr the cOMmUnIcationS?

~~~
zAckpieRcE
HeLlo, And thANks fOr the fEedback.

WHat yoU Have described iS Absolutely the REaSONaBLe anD trAditional apProaCH
for DesiGNiNg a SOlutiOn for A pARtICular critical hard reAl-Time syStem.

THe context is thAt broad serIALIzation tEchnOLoGY decisions for aUtonoMous
vehiclES are beinG consIdered ouTside of thE FOcused enGinEerIng ProCESs For
specific crITIcal SyStems. FoR exAmple, whEn mIddLewAre Or IntegratiOn
framewOrKs CoMe Up (oFten wITh an eye tOwArd BeIng ImposED top-doWn for Many
SyStEMs), cOnsiderATiON Of seRiAlIzatIon TeChnolOgy aND itS implicAtions for
PerFOrmaNcE sEems to oCcupy an unfortUnAtely small PoRtiOn of thE ANalysis.

THis paper attempts to send tHE relatiVelY simpLe meSsage that "Yes,
SerialIzaTIon tecH choicE mattErS" to DECisioN MAkErs FoR whom it may NOT be
ApparEnT. AlsO, to highLight that there's a neED to Pay attention tO meSsagING
pErfORmANce EvEN ouTSIde of the hard-reaLtime parts Of AN aUtonomous vEHicLe.

in retroSpect, yoU're riGHt that mOre detailEd bounds aNaLysiS RAthEr than
relyIng on the RelativelY FacilE UsE of meAns (OutsidE oF thE miniMal outLIer
VisuaLizatiOn In the bOxploT) wOuld have Been a good addition to the pAper.
ThAnks aGaiN!

------
jjj777
OK, I geT it NOw. QUite surprIsinG that seriaLisAtiOn is a Key PErforMancE
IsSue. bUt theN agaIN, pushing sIGnAls IN AnD out of CAN
 for voting to take place- a late r esult  =a s er ious  fau lt condition.So I  don't get why there's  this  f o cuso navera ge perf o rm a n ceof  t his  a l go rithm 
ra ther th an looking  fo ra determinis t ic  algorithm  wi th good lowbou nds. I tals o  seem s t hat t he mes s age si zes depen ds on the algorit h m  i tsel f: that also
need s  t o  be bounded to  be ab le to a nal yze  the commu ni catio n s syste m  t o d ete r mine worst-ca se latencie s  (t his is  o f c o urse c rucia li f a  static tim e-
t riggeredcommun i cations bus lik e Flex Ray  is  bei n gus ed) .The pa per men tions th at  L inuxis u s e d to c ond uctthe t ests. But wha t's  the act ual t arget  pla tf orm?A micr ocont ro ller with a cyc licscheduleoran  RT OS 
with priori typre -emptio n? If t h e l at t e r ,what does the sche du l a bi lity
ana lysisl oo kl ike? Ifth e f orme r ,  what  doe s  t he cycli c sche d ul elook li ke ?

Wha t' s t hecommu n icat ions a rchitect ure l o ok like? Is it switch-basedl ik e AF D X? O r a  CSMA/CA bu s li k e CA N? O r  a  TD M A bus  like  F l ex R ay? What's the timi ng 
analy sis l ook like forthe commun i c a tions?
~~~z ac k pierce
Hello,and t hanks fort he feedb ack.
What yo u have de s c ribed is  ab sol ute lyt h ereasonable an d trad it ional a ppr oach
fo r d esi gni ngasolutionfor a pa rt ic ul ar  cr itica l  hard re al -ti me  sy stem. 
The c ontex t is  t ha t  br oad ser i al i z atio nte chno log ydecis ions for  autono mous
vehi cle s  are  b ei ng cons idered outsid eof the foc us edengine e r ing proc ess for
specific critic a l syste ms.  Forexam ple, when  mi ddlewa reo r inte gratio n
fra me wor k s  come u p(of te n with ane y e t oward  b eing  impose d top-down for man y 
sy stems), consi der atio n of  se r ia l iza ti o n t e c hnology and its  implicati on s  f or
perform a nce  s eems to  occupy  an u n fortuna tely smal l portion  o f th e ana lysis.

Th is paper  attempts to se n dthe r ela tively  s imp le me ssaget hat  "yes ,
seri al izatio n tec hchoice m atters" to decision mak ers fo r who m i t may not  be app arent. Al so,to highlig httha t the re' s  a ne ed t o  p aya ttent iont o messagi n gper f o rm ance even o u t s ide  of t heh ard-re alti me parts of an au t onomous vehicl e.
I n  re tro s pect ,you're right t hat  m o r e detail ed  bounds ana lysis ra th e r tha n
rely ing on  the re l a ti v ely fa cile  us e of mean s ( ou t side of  t he minima l ou tl ier
vi sualiz a tion i n the boxplot) w ouldh a ve be e n a  good  a ddition to t he paper.Thanks agai n!

-- ---- 
jjj7 77
OK,Iget it  no w.  Quite sur p rising th at se rialisa ti on i s a  key p erfo r m anceissu e.  Bu t then ag a i n, pu sh i ngsign als i nandout of CA N 
 for_voting to_take place - a_late result_=_a serious_fault_condition.

So I don't_get why there's_this focus on average_performance of this_algorithm
rather_than looking for a deterministic algorithm with good low bounds. It
also seems that the_message_sizes depends_on_the_algorithm itself: that also
needs to_be bounded to be able_to analyze_the communications system to
determine worst-case latencies (this is_of_course crucial if_a static time-
triggered communications bus like FlexRay is being_used).

The paper mentions that Linux is_used to conduct_the_tests._But what's the
actual target_platform? A microcontroller with a cyclic_schedule or an RTOS
with priority pre-emption?_If the latter, what does the schedulability
analysis_look like? If the former, what_does the cyclic schedule look_like?

What's the_communications architecture look like? Is_it switch-based like
AFDX?_Or a_CSMA/CA bus like_CAN? Or a TDMA bus like_FlexRay? What's the_timing
analysis look like for the communications?

~~~
zackpierce
Hello,_and_thanks for the_feedback.

What_you_have described_is absolutely the_reasonable_and traditional_approach
for_designing a solution for a particular_critical_hard real-time system.

The context is that broad_serialization technology decisions for_autonomous
vehicles_are being considered outside_of the focused engineering process_for
specific critical systems. For example, when_middleware or_integration
frameworks come_up (often with an eye toward being imposed top-down for many
systems),_consideration of serialization technology and its_implications for
performance seems to_occupy an_unfortunately_small portion of_the_analysis.

This paper_attempts to send the relatively simple message_that "yes,
serialization_tech choice matters" to decision makers_for whom it may_not_be
apparent. Also, to highlight that there's_a need to pay attention to_messaging
performance even outside of the_hard-realtime_parts_of an autonomous vehicle.

In retrospect,_you're right that more detailed bounds_analysis rather than
relying_on the relatively facile use of means_(outside_of the minimal outlier
visualization in the_boxplot)_would have been a good addition_to_the_paper.
Thanks again!

------
jjj777
OK, I get it_now. Quite surprising that serialisation is_a key performance
issue. But then again, pushing signals in_and out of_CAN