void ArcNet::Initialize_Timing_Plans (Timing_File &file)
{
Data_Service::Initialize_Timing_Plans (file);
if (timing_db.capacity () == 0) {
int num = file.Num_Records ();
if (num > 0) timing_db.reserve (num);
}
}
void Data_Service::Write_Timing_Plans (void)
{
Timing_File *file = System_Timing_File (true);
int count = 0;
Int_Map_Itr map_itr;
Show_Message (String ("Writing %s -- Record") % file->File_Type ());
Set_Progress ();
for (map_itr = signal_map.begin (); map_itr != signal_map.end (); map_itr++) {
Show_Progress ();
count += Put_Timing_Data (*file, signal_array [map_itr->second]);
}
Show_Progress (count);
End_Progress ();
file->Close ();
Print (2, String ("%s Records = %d") % file->File_Type () % count);
}
bool SubareaNet::Get_Timing_Data (Timing_File &file, Timing_Record &data)
{
//---- do standard processing ----
if (Data_Service::Get_Timing_Data (file, data)) {
//---- copy the fields to the subarea file ----
Db_Header *new_file = System_File_Header (NEW_TIMING_PLAN);
new_file->Copy_Fields (file);
if (!new_file->Write (file.Nested ())) {
Error (String ("Writing %s") % new_file->File_Type ());
}
ntiming++;
}
return (false);
}
int ArcNet::Get_Timing_Data (Timing_File &file, Timing_Data &timing_rec)
{
int signal = Data_Service::Get_Timing_Data (file, timing_rec);
if (signal >= 0) {
timing_db.Copy_Fields (file);
if (!file.Nested ()) {
if (time_flag) {
Signal_Data *signal_ptr = &signal_array [signal];
Signal_Time_Itr itr;
bool keep = false;
for (itr = signal_ptr->begin (); itr != signal_ptr->end (); itr++) {
if (itr->Timing () == timing_rec.Timing () &&
itr->Start () <= time && time <= itr->End ()) {
keep = true;
break;
}
}
if (!keep) {
timing_rec.Timing (-1);
return (-1);
}
}
return (signal);
}
if (timing_rec.Timing () >= 0) {
if (!timing_db.Add_Record ()) {
Error ("Writing Timing Plan Database");
}
return (signal);
}
}
return (-1);
}
bool Data_Service::Get_Timing_Data (Timing_File &file, Timing_Record &timing_rec)
{
int signal;
Int_Map_Itr map_itr;
Timing_Data *timing_ptr = &(timing_rec.timing_data);
//---- process the header record ----
if (!file.Nested ()) {
timing_ptr->Timing (file.Timing ());
if (timing_ptr->Timing () == 0) return (false);
timing_ptr->Type (file.Type ());
timing_ptr->Cycle (file.Cycle ());
timing_ptr->Offset (file.Offset ());
timing_ptr->Notes (file.Notes ());
if (file.Version () > 40) {
signal = file.Signal ();
if (signal == 0) return (false);
map_itr = signal_map.find (signal);
if (map_itr == signal_map.end ()) {
Warning (String ("Timing Signal %d was Not Found") % signal);
return (false);
}
timing_rec.Signal (map_itr->second);
return (true);
}
}
Timing_Phase phase_rec;
phase_rec.Phase (file.Phase ());
phase_rec.Barrier (file.Barrier ());
phase_rec.Ring (file.Ring ());
phase_rec.Position (file.Position ());
phase_rec.Min_Green (file.Min_Green ());
phase_rec.Max_Green (file.Max_Green ());
phase_rec.Extension (file.Extension ());
phase_rec.Yellow (file.Yellow ());
phase_rec.All_Red (file.All_Red ());
if (phase_rec.Max_Green () == 0) phase_rec.Max_Green (phase_rec.Min_Green () + phase_rec.Extension ());
timing_ptr->push_back (phase_rec);
return (timing_rec.Signal () >= 0 || file.Version () <= 40);
}
void Data_Service::Read_Timing_Plans (Timing_File &file)
{
int i, num, count;
bool keep;
Timing_Record timing_rec;
Timing_Data *timing_ptr;
Signal_Data *signal_ptr;
//---- store the timing plan data ----
Show_Message (String ("Reading %s -- Record") % file.File_Type ());
Set_Progress ();
Initialize_Timing_Plans (file);
count = 0;
timing_ptr = &(timing_rec.timing_data);
while (file.Read (false)) {
Show_Progress ();
timing_rec.Clear ();
keep = Get_Timing_Data (file, timing_rec);
num = file.Num_Nest ();
if (num > 0) timing_ptr->reserve (num);
for (i=1; i <= num; i++) {
if (!file.Read (true)) {
Error (String ("Number of Phase Records for Signal %d Plan %d") %
file.Signal () % file.Timing ());
}
Show_Progress ();
Get_Timing_Data (file, timing_rec);
}
//---- save the results ----
if (keep) {
if (file.Version () <= 40) {
bool keep;
Timing40_Map_Itr timing40_itr;
Timing40_Data *timing40_ptr;
Timing_Itr timing_itr;
timing40_itr = timing40_map.find (timing_ptr->Timing ());
if (timing40_itr == timing40_map.end ()) {
Warning (String ("Timing Plan %d was Not Found in the Signal file") % timing_ptr->Timing ());
continue;
}
timing40_ptr = (Timing40_Data *) &(timing40_itr->second);
timing_rec.Signal (timing40_ptr->Signal ());
signal_ptr = &signal_array [timing_rec.Signal ()];
keep = true;
for (timing_itr = signal_ptr->timing_plan.begin (); timing_itr != signal_ptr->timing_plan.end (); timing_itr++) {
if (timing_itr->Timing () == timing40_ptr->Timing ()) {
Timing_Phase_Itr phase_itr = timing_ptr->begin ();
timing_itr->push_back (*phase_itr);
count++;
keep = false;
break;
}
}
if (!keep) continue;
timing_ptr->Timing (timing40_ptr->Timing ());
timing_ptr->Type (timing40_ptr->Type ());
timing_ptr->Offset (timing40_ptr->Offset ());
} else {
signal_ptr = &signal_array [timing_rec.Signal ()];
}
signal_ptr->timing_plan.push_back (*timing_ptr);
count += (int) timing_ptr->size () + 1;
}
}
End_Progress ();
file.Close ();
Print (2, String ("Number of %s Records = %d") % file.File_Type () % Progress_Count ());
if (count && count != Progress_Count ()) {
Print (1, String ("Number of %s Data Records = %d") % file.File_ID () % count);
}
if (count > 0) System_Data_True (TIMING_PLAN);
//---- repair Version 4.0 data ----
if (file.Version () <= 40) {
int first, prev, next, barrier, ring, position, cycle;
bool flag;
Signal_Itr signal_itr;
Timing_Itr timing_itr;
Timing_Phase_Itr phase_itr;
for (signal_itr = signal_array.begin (); signal_itr != signal_array.end (); signal_itr++) {
for (timing_itr = signal_itr->timing_plan.begin (); timing_itr != signal_itr->timing_plan.end (); timing_itr++) {
//---- map the ring positions ----
for (ring=1; ; ring++) {
flag = false;
for (phase_itr = timing_itr->begin (); phase_itr != timing_itr->end (); phase_itr++) {
if (phase_itr->Ring () == ring) {
flag = true;
break;
}
}
if (!flag) break;
first = prev = phase_itr->Phase ();
next = phase_itr->Position ();
barrier = phase_itr->Barrier ();
if (barrier == 0) {
phase_itr->Barrier ((barrier = 1));
}
count = (int) timing_itr->size ();
position = 1;
phase_itr->Position (position);
cycle = MAX ((phase_itr->Min_Green () + phase_itr->Extension ()), phase_itr->Max_Green ()) +
phase_itr->Yellow () + phase_itr->All_Red ();
while (next != first && count-- > 0) {
flag = false;
for (phase_itr = timing_itr->begin (); phase_itr != timing_itr->end (); phase_itr++) {
if (phase_itr->Phase () == next) {
flag = true;
break;
}
}
if (!flag) {
Warning (String ("Signal %d Timing %d Phase %d was Not Found") %
signal_itr->Signal () % timing_itr->Timing () % next);
break;
}
if (phase_itr->Ring () == 0) {
phase_itr->Ring (ring);
} else if (phase_itr->Ring () != ring) {
Warning (String ("Signal %d Timing %d Phase %d to %d is Not in Ring %d") %
signal_itr->Signal () % timing_itr->Timing () % prev % next % ring);
break;
}
if (phase_itr->Barrier () == 0) {
phase_itr->Barrier (barrier);
}
if (phase_itr->Barrier () == barrier) {
position++;
} else {
position = 1;
barrier = phase_itr->Barrier ();
}
prev = next;
next = phase_itr->Position ();
phase_itr->Position (position);
cycle += MAX ((phase_itr->Min_Green () + phase_itr->Extension ()), phase_itr->Max_Green ()) +
phase_itr->Yellow () + phase_itr->All_Red ();
}
if (ring == 1) {
timing_itr->Cycle (cycle);
}
}
}
}
}
}
int Data_Service::Put_Timing_Data (Timing_File &file, Signal_Data &data)
{
Int_Map_Itr map_itr;
Timing_Itr timing_itr;
Timing_Phase_Itr phase_itr;
int i, num, count;
Timing_Phase *phase_sort [20];
file.Signal (data.Signal ());
count = 0;
for (timing_itr = data.timing_plan.begin (); timing_itr != data.timing_plan.end (); timing_itr++) {
Show_Progress ();
file.Timing (timing_itr->Timing ());
file.Type (timing_itr->Type ());
file.Cycle (timing_itr->Cycle ());
file.Offset (timing_itr->Offset ());
file.Phases ((int) timing_itr->size ());
file.Notes (timing_itr->Notes ());
if (!file.Write (false)) {
Error (String ("Writing %s") % file.File_Type ());
}
count++;
num = 0;
memset (phase_sort, '\0', sizeof (phase_sort));
for (phase_itr = timing_itr->begin (); phase_itr != timing_itr->end (); phase_itr++) {
i = phase_itr->Phase ();
if (i >= 20) continue;
if (i > num) num = i;
phase_sort [i] = &(*phase_itr);
}
for (i=1; i <= num; i++) {
if (phase_sort [i] == 0) continue;
file.Phase (phase_sort [i]->Phase ());
file.Barrier (phase_sort [i]->Barrier ());
file.Ring (phase_sort [i]->Ring ());
file.Position (phase_sort [i]->Position ());
file.Min_Green (phase_sort [i]->Min_Green ());
file.Max_Green (phase_sort [i]->Max_Green ());
file.Extension (phase_sort [i]->Extension ());
file.Yellow (phase_sort [i]->Yellow ());
file.All_Red (phase_sort [i]->All_Red ());
if (!file.Write (true)) {
Error (String ("Writing %s") % file.File_Type ());
}
count++;
}
}
return (count);
}
