static int report_error_detected(struct pci_dev *dev, void *data)
{
pci_ers_result_t vote;
struct pci_error_handlers *err_handler;
struct aer_broadcast_data *result_data;
result_data = (struct aer_broadcast_data *) data;
dev->error_state = result_data->state;
if (!dev->driver ||
!dev->driver->err_handler ||
!dev->driver->err_handler->error_detected) {
if (result_data->state == pci_channel_io_frozen &&
!(dev->hdr_type & PCI_HEADER_TYPE_BRIDGE)) {
/*
* In case of fatal recovery, if one of down-
* stream device has no driver. We might be
* unable to recover because a later insmod
* of a driver for this device is unaware of
* its hw state.
*/
dev_printk(KERN_DEBUG, &dev->dev, "device has %s\n",
dev->driver ?
"no AER-aware driver" : "no driver");
}
return 0;
}
err_handler = dev->driver->err_handler;
vote = err_handler->error_detected(dev, result_data->state);
result_data->result = merge_result(result_data->result, vote);
return 0;
}
static int error_detected_iter(struct device *device, void *data)
{
struct pcie_device *pcie_device;
struct pcie_port_service_driver *driver;
struct aer_broadcast_data *result_data;
pci_ers_result_t status;
result_data = (struct aer_broadcast_data *) data;
if (device->bus == &pcie_port_bus_type && device->driver) {
driver = to_service_driver(device->driver);
if (!driver ||
!driver->err_handler ||
!driver->err_handler->error_detected)
return 0;
pcie_device = to_pcie_device(device);
/* Forward error detected message to service drivers */
status = driver->err_handler->error_detected(
pcie_device->port,
result_data->state);
result_data->result =
merge_result(result_data->result, status);
}
return 0;
}
void TemplateFrame::OnSaveImageWithLegendAs(wxCommandEvent& event)
{
LOG_MSG("Entering TemplateFrame::OnSaveImageWithLegendAs");
if (template_legend) {
wxSize canvas_size = template_canvas->GetVirtualSize();
wxSize legend_size = template_legend->GetVirtualSize();
wxBitmap merge_result(canvas_size.x + legend_size.x,
legend_size.y);
wxMemoryDC dc;
dc.SelectObject(merge_result);
wxBrush brush;
brush.SetColour(template_legend->GetBackgroundColour());
dc.SetBrush(brush);
//dc.DrawRectangle(0, 0, merge_result.GetSize().x, merge_result.GetSize().y);
dc.SetPen(*wxTRANSPARENT_PEN);
dc.DrawRectangle(0, 0, legend_size.x, legend_size.y);
dc.SetPen(*wxBLACK_PEN);
template_legend->OnDraw(dc);
dc.DrawBitmap(*template_canvas->GetLayer2(), legend_size.x, 0);
dc.SelectObject(wxNullBitmap);
ExportImageWithLegend(&merge_result, activeFrName);
} else {
OnSaveCanvasImageAs(event);
}
LOG_MSG("Leaving TemplateFrame::OnSaveImageWithLegendAs");
}
static int report_error_detected(struct pci_dev *dev, void *data)
{
pci_ers_result_t vote;
struct pci_error_handlers *err_handler;
struct aer_broadcast_data *result_data;
result_data = (struct aer_broadcast_data *) data;
dev->error_state = result_data->state;
if (!dev->driver ||
!dev->driver->err_handler ||
!dev->driver->err_handler->error_detected) {
if (result_data->state == pci_channel_io_frozen &&
!(dev->hdr_type & PCI_HEADER_TYPE_BRIDGE)) {
dev_printk(KERN_DEBUG, &dev->dev, "device has %s\n",
dev->driver ?
"no AER-aware driver" : "no driver");
}
return 0;
}
err_handler = dev->driver->err_handler;
vote = err_handler->error_detected(dev, result_data->state);
result_data->result = merge_result(result_data->result, vote);
return 0;
}
static int report_error_detected(struct pci_dev *dev, void *data)
{
pci_ers_result_t vote;
const struct pci_error_handlers *err_handler;
struct aer_broadcast_data *result_data;
result_data = (struct aer_broadcast_data *) data;
device_lock(&dev->dev);
dev->error_state = result_data->state;
if (!dev->driver ||
!dev->driver->err_handler ||
!dev->driver->err_handler->error_detected) {
if (result_data->state == pci_channel_io_frozen &&
dev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
/*
* In case of fatal recovery, if one of down-
* stream device has no driver. We might be
* unable to recover because a later insmod
* of a driver for this device is unaware of
* its hw state.
*/
dev_printk(KERN_DEBUG, &dev->dev, "device has %s\n",
dev->driver ?
"no AER-aware driver" : "no driver");
}
/*
* If there's any device in the subtree that does not
* have an error_detected callback, returning
* PCI_ERS_RESULT_NO_AER_DRIVER prevents calling of
* the subsequent mmio_enabled/slot_reset/resume
* callbacks of "any" device in the subtree. All the
* devices in the subtree are left in the error state
* without recovery.
*/
if (dev->hdr_type != PCI_HEADER_TYPE_BRIDGE)
vote = PCI_ERS_RESULT_NO_AER_DRIVER;
else
vote = PCI_ERS_RESULT_NONE;
} else {
err_handler = dev->driver->err_handler;
vote = err_handler->error_detected(dev, result_data->state);
}
result_data->result = merge_result(result_data->result, vote);
device_unlock(&dev->dev);
return 0;
}
static int report_slot_reset(struct pci_dev *dev, void *data)
{
pci_ers_result_t vote;
struct pci_error_handlers *err_handler;
struct aer_broadcast_data *result_data;
result_data = (struct aer_broadcast_data *) data;
if (!dev->driver ||
!dev->driver->err_handler ||
!dev->driver->err_handler->slot_reset)
return 0;
err_handler = dev->driver->err_handler;
vote = err_handler->slot_reset(dev);
result_data->result = merge_result(result_data->result, vote);
return 0;
}
static void report_mmio_enabled(struct pci_dev *dev, void *data)
{
pci_ers_result_t vote;
struct pci_error_handlers *err_handler;
struct aer_broadcast_data *result_data;
result_data = (struct aer_broadcast_data *) data;
if (!dev->driver ||
!dev->driver->err_handler ||
!dev->driver->err_handler->mmio_enabled)
return;
err_handler = dev->driver->err_handler;
vote = err_handler->mmio_enabled(dev);
result_data->result = merge_result(result_data->result, vote);
return;
}
static int report_slot_reset(struct pci_dev *dev, void *data)
{
pci_ers_result_t vote;
const struct pci_error_handlers *err_handler;
struct aer_broadcast_data *result_data;
result_data = (struct aer_broadcast_data *) data;
device_lock(&dev->dev);
if (!dev->driver ||
!dev->driver->err_handler ||
!dev->driver->err_handler->slot_reset)
goto out;
err_handler = dev->driver->err_handler;
vote = err_handler->slot_reset(dev);
result_data->result = merge_result(result_data->result, vote);
out:
device_unlock(&dev->dev);
return 0;
}
static int slot_reset_iter(struct device *device, void *data)
{
struct pcie_device *pcie_device;
struct pcie_port_service_driver *driver;
pci_ers_result_t status, *result;
result = (pci_ers_result_t *) data;
if (device->bus == &pcie_port_bus_type && device->driver) {
driver = to_service_driver(device->driver);
if (driver &&
driver->err_handler &&
driver->err_handler->slot_reset) {
pcie_device = to_pcie_device(device);
/* Forward error message to service drivers */
status = driver->err_handler->slot_reset(
pcie_device->port);
*result = merge_result(*result, status);
}
}
return 0;
}
static int mmio_enabled_iter(struct device *device, void *data)
{
struct pcie_device *pcie_device;
struct pcie_port_service_driver *driver;
pci_ers_result_t status, *result;
result = (pci_ers_result_t *) data;
if (device->bus == &pcie_port_bus_type && device->driver) {
driver = to_service_driver(device->driver);
if (driver &&
driver->err_handler &&
driver->err_handler->mmio_enabled) {
pcie_device = to_pcie_device(device);
status = driver->err_handler->mmio_enabled(
pcie_device->port);
*result = merge_result(*result, status);
}
}
return 0;
}
int main(int argc, char** argv) {
if (argc < 2) {
printf("%s data_dir\n", argv[0]);
exit(-1);
}
memset(DATA_DIR, 0, 1024 * sizeof(DATA_DIR[1024]));
snprintf(DATA_DIR, 1024, "%s", argv[1]);
if (access(DATA_DIR, 0) != 0) {
printf("%s isnot exist\n", DATA_DIR);
printf("%s data_dir\n", argv[0]);
exit(-1);
}
LossMiddleName *loss_middle_name = LossMiddleName::get_instance();
CAuthorList *author_list = CAuthorList::get_instance();
CPaPerAuthorList *paper_author_list = CPaPerAuthorList::get_instance();
CPaperList *paper_list = CPaperList::get_instance();
#ifdef DEBUG
paper_author_list->print_name_count();
#endif
vector<int> *author_id_list = author_list->get_author_id_list();
map<int, CAuthor*> *author_map = author_list->get_author_map();
map<int, vector<Candidate> > *author_similar_map;
#ifdef DEBUGTEST
test();
#endif
// 1. valid the lost middle name type
vector<int> *only_author_id_list = author_list->get_only_author_id_list();
NameIndex *name_index = NameIndex::get_instance();
// 1.1 find the middle name by using the author name
for (unsigned int i = 0; i < only_author_id_list->size(); ++i) {
int author_id1 = (*only_author_id_list)[i];
CAuthor *author1 = author_list->get_author_by_id(author_id1);
if (author1 == NULL) {
continue;
}
author1->add_is_loss_middle_name();
if (author1->get_cname()->is_abbr && author1->get_names_size() < 4) {
continue;
}
vector<SubName> &names = author1->get_cname()->names;
for (unsigned int i = 0; i < names.size(); ++i) {
if (names[i].abbr_type == ABBR_TYPE) {
continue;
}
string string_name = names[i].text;
list<int> *name_index_by_name =
name_index->get_name_index(string_name);
if (name_index_by_name == NULL) {
continue;
}
for (list<int>::iterator beg = name_index_by_name->begin();
beg != name_index_by_name->end();
++beg) {
int author_id2 = *beg;
CAuthor *author2 = author_list->get_author_by_id(author_id2);
if (author2 == NULL) {
continue;
}
if (author1->get_cname()->is_lost_middle_name(author2->get_cname(), FROM_CG)) {
loss_middle_name->add(author1->get_cname(), author2->get_cname());
}
}
}
}
// 1.2 find the middle name by using the game name
for (unsigned int i = 0; i < only_author_id_list->size(); ++i) {
int author_id1 = (*only_author_id_list)[i];
CAuthor *author1 = author_list->get_author_by_id(author_id1);
vector<CName*> &game_names = author1->get_mypaper_name_list();
for (unsigned int m = 0; m < game_names.size(); ++m) {
CName* game_name = game_names[m];
if (game_name->is_abbr && game_name->names.size() < 4) {
continue;
}
vector<SubName> &names = game_name->names;
for (unsigned int i = 0; i < names.size(); ++i) {
if (names[i].abbr_type == ABBR_TYPE) {
continue;
}
string string_name = names[i].text;
list<int> *name_index_by_name =
name_index->get_name_index(string_name);
if (name_index_by_name == NULL) {
continue;
}
for (list<int>::iterator beg = name_index_by_name->begin();
beg != name_index_by_name->end();
++beg) {
int author_id2 = *beg;
CAuthor *author2 = author_list->get_author_by_id(author_id2);
/*
if (author2->get_cname()->_GetNameSimilarType(game_name) > 0) {
continue;
}
*/
if (author2->get_cname()->is_lost_middle_name(game_name, FROM_CG)) {
loss_middle_name->add(game_name, author2->get_cname());
}
}
}
}
}
// 1.3 valid
loss_middle_name->valid();
// 2. create game_name
for (unsigned int i = 0; i < author_id_list->size(); ++i) {
int author_id = (*author_id_list)[i];
CAuthor *author = author_list->get_author_by_id(author_id);
if (author == NULL) {
continue;
}
author->create_game_name();
}
// 3. find the similar author
// 3.1 use the simply name of the author name
for (unsigned int i = 0; i < author_id_list->size(); ++i) {
int author_id = (*author_id_list)[i];
CAuthor *author = (*author_map)[author_id];
if (author->get_paper_num() == 0) {
continue;
}
string simply_name = author->get_simply_name();
if (simply_name.length() > 1) {
list<int> *same_simply_name_list =
author_list->get_same_simply_name_list(simply_name);
if (same_simply_name_list == NULL) {
continue;
}
for (list<int>::iterator same_simplys_it = same_simply_name_list->begin();
same_simplys_it != same_simply_name_list->end();
++same_simplys_it) {
CAuthor *one = (*author_map)[*same_simplys_it];
if (author_id == *same_simplys_it) {
continue;
}
author->AddNameCandidates(one, 0);
}
}
}
printf("CANDIDATE using author name[%d]\n", get_candidates_num(author_id_list, author_map));
// 3.2 using the simply name of the game name
for (unsigned int i = 0; i < author_id_list->size(); ++i) {
int author_id = (*author_id_list)[i];
CAuthor *author = (*author_map)[author_id];
if (author->get_paper_num() == 0) {
continue;
}
if (author->get_is_game_name()) {
vector<CName*> &game_names = author->get_game_names();
for (unsigned int k = 0; k < game_names.size(); ++k) {
list<int> *same_simply_name_list
= author_list->get_same_simply_name_list(game_names[k]->simply_name);
if (same_simply_name_list == NULL) {
continue;
}
for (list<int>::iterator same_simplys_it = same_simply_name_list->begin();
same_simplys_it != same_simply_name_list->end();
++same_simplys_it) {
CAuthor *one = (*author_map)[*same_simplys_it];
if (author_id == *same_simplys_it) {
continue;
}
if (author->get_cname()->names.size() > game_names[k]->names.size()
&& one->get_cname()->names.size() > game_names[k]->names.size()) {
continue;
}
int similar = author->AddNameCandidates(one, k+1);
#ifdef DEBUG
if (similar > 0) {
printf("GGGGG:[%s] [%d]\n",
game_names[k]->normalized_name.c_str(), author->get_paper_num());
}
#endif
}
}
}
}
printf("CANDIDATE using game name[%d]\n", get_candidates_num(author_id_list, author_map));
// 3.3 using the subname of the author name
for (unsigned int i = 0; i < only_author_id_list->size(); ++i) {
int author_id1 = (*only_author_id_list)[i];
CAuthor *author1 = author_list->get_author_by_id(author_id1);
if (author1->get_cname()->is_abbr && author1->get_names_size() < 4) {
continue;
}
vector<SubName> &names = author1->get_cname()->names;
for (unsigned int i = 0; i < names.size(); ++i) {
if (names[i].abbr_type == ABBR_TYPE) {
continue;
}
string string_name = names[i].text;
list<int> *name_index_by_name =
name_index->get_name_index(string_name);
if (name_index_by_name == NULL) {
continue;
}
for (list<int>::iterator beg = name_index_by_name->begin();
beg != name_index_by_name->end();
++beg) {
int author_id2 = *beg;
if (author_id1 > author_id2) {
continue;
}
CAuthor *author2 = author_list->get_author_by_id(author_id2);
if (author2->get_paper_num() < 1) {
continue;
}
if (author1->ContainCandidate(author_id2)) {
continue;
}
if ((author2->get_cname()->is_abbr == false || author2->get_names_size() > 3)) {
int type = author1->get_game_name_similar_strict_type(author2, author2->get_cname());
if (type < 0) {
continue;
}
author1->AddSameAuthorCandidate(author2, MERGER_SPECIAL_SCORE, -1, -1);
#ifdef DEBUG
printf("XXX [%d] [%s] [%s]\n", type, author1->get_cname()->normalized_name.c_str(), author2->get_cname()->normalized_name.c_str());
#endif
}
}
}
}
printf("CANDIDATE using name index name[%d]\n", get_candidates_num(author_id_list, author_map));
int merger_count = 1;
int times = 0;
// 4 check and merge result
merge_result(author_id_list, author_map);
// 5 write result
FILE *fout = fopen("result.csv", "w");
#ifdef DEBUG
memset(file_name_out, 0, sizeof(file_name_out[0])*128);
sprintf(file_name_out, "%s/%s", DIR, "result.info");
FILE *fout_info = fopen(file_name_out, "w");
#endif
int candidates_sum = 0;
int author_sum = 0;
int transfer = 0;
for (unsigned int i = 0; i < author_id_list->size(); ++i) {
int author_id = (*author_id_list)[i];
CAuthor *author = (*author_map)[author_id];
vector<Candidate> &candidates = author->get_same_author_candidates();
/*
if (author->get_is_game_name()) {
vector<CName*> game_names = author->get_game_names();
for (unsigned int k = 0; k < game_names.size(); ++k) {
delete_candidate(candidates, *author, 1+k);
}
}
if (author->get_is_game_name()) {
vector<CName*> game_names = author->get_game_names();
for (unsigned int k = 0; k < game_names.size(); ++k) {
valid(candidates, *author, 1+k);
}
}
*/
if (candidates.size() > 1) {
qsort(&candidates[0], candidates.size(), sizeof(Candidate), cmp);
}
fprintf(fout, "%d,%d", author_id, author_id);
int diff = 0;
for (unsigned int j = 0; j < candidates.size(); ++j) {
fprintf(fout, " %d", candidates[j].author_id);
CAuthor *one = (*author_map)[candidates[j].author_id];
if (candidates.size() > one->get_same_author_candidates().size()) {
diff = one->get_same_author_candidates().size() - candidates.size();
}
}
if (candidates.size() > 0) {
#ifdef DEBUG
fprintf(fout_info, "++:%d %s\n", author_id, author->get_cname()->ToString().c_str());
for (unsigned int j = 0; j < candidates.size(); ++j) {
CAuthor *one = (*author_map)[candidates[j].author_id];
fprintf(fout_info, "---:%d\t%s\n", candidates[j].author_id, one->get_cname()->ToString().c_str());
}
#endif
++author_sum;
}
#ifdef DEBUG
if (candidates.size() > 20) {
printf("SOMUCH\n");
for (unsigned int j = 0; j < candidates.size(); ++j) {
CAuthor *one = (*author_map)[candidates[j].author_id];
one->Print();
}
}
#endif
transfer += diff;
fprintf(fout, "\n");
}
int get_candidates_num_end = get_candidates_num(author_id_list, author_map);
printf("candidates_sum:[%d] author_sum:[%d] transfer:[%d]\n",
get_candidates_num_end, author_sum, transfer);
}
