Exemplo n.º 1
0
void _step_complete_msg_proc(slurm_msg_t* msg)
{
	slurm_send_rc_msg(msg, SLURM_SUCCESS);
	step_complete_msg_t *complete = (step_complete_msg_t*) msg->data;

	/* get the job id */
	char str_job_id[20] = { 0 };
	sprintf(str_job_id, "%u", complete->job_id);
	/* lookup for the origin controller id of this job */
	char *origin_ctrlid = c_calloc(30);
	c_zht_lookup(str_job_id, origin_ctrlid);

	pthread_mutex_lock(&lookup_msg_mutex);
	num_lookup_msg++;
	pthread_mutex_unlock(&lookup_msg_mutex);

	/* concat to get the jobid+origin_ctrlid */
	char *jobid_origin_ctrlid = c_calloc(strlen(origin_ctrlid) + 30 + 2);
	strcat(jobid_origin_ctrlid, str_job_id);
	strcat(jobid_origin_ctrlid, origin_ctrlid);

	/* create the job resource from looking up zht */
	job_resource *a_job_res = _create_job_resource(jobid_origin_ctrlid);
	release_res(a_job_res);
	free_job_resource(a_job_res);

	/* check to see whether this job belongs to the controller */
	if (!strcmp(self_id, origin_ctrlid))
	{
		pthread_mutex_lock(&num_job_fin_mutex);
		num_job_fin++;
		pthread_mutex_unlock(&num_job_fin_mutex);
		unsigned long time_in_micros = get_current_time();
		pthread_mutex_lock(&job_output_mutex);
		fprintf(job_output_file, "%u\tend time\t%lu\n", complete->job_id, time_in_micros);
		pthread_mutex_unlock(&job_output_mutex);
	}
	else	// if it is not, then insert a notification message
	{
		char *key = c_calloc(strlen(jobid_origin_ctrlid) + 5);
		strcat(key, jobid_origin_ctrlid);
		strcat(key, "Fin");
		c_zht_insert(key, "Finished");
		pthread_mutex_lock(&insert_msg_mutex);
		num_insert_msg++;
		pthread_mutex_unlock(&insert_msg_mutex);
		c_free(key);
	}
	c_free(origin_ctrlid);
	c_free(jobid_origin_ctrlid);
	/*pthread_mutex_lock(&lookup_msg_mutex);
	num_lookup_msg += num_lookup_msg_local;
	pthread_mutex_unlock(&lookup_msg_mutex);
	pthread_mutex_lock(&insert_msg_mutex);
	num_insert_msg += num_insert_msg_local;
	pthread_mutex_unlock(&insert_msg_mutex);
	pthread_mutex_lock(&cswap_msg_mutex);
	num_cswap_msg += num_comswap_msg_local;
	pthread_mutex_unlock(&cswap_msg_mutex);*/
}
/**
 * Desc: get the open mode of the file:
 * Return: 000 - not open; 001 - read only; 010 - write only; 011 - read and write; -1 - failed
 */
int zht_get_openmode(const char *virtualfname)
{
	char *buf; // Buffer to store serialized data
	unsigned len; // Length of serialized data
	char result[ZHT_MAX_BUFF] = {0}; //return result
	size_t ln; //return length
	int rtn;

	Package package = PACKAGE__INIT; // Package
	package.virtualpath = (char*)virtualfname;
	package.realfullpath = "";
	package.has_operation = true;
	package.operation = 1; //1 for look up, 2 for remove, 3 for insert

	len = package__get_packed_size(&package);
	buf = (char*) calloc(len, sizeof(char));
	package__pack(&package, (uint8_t *)buf);

	int lret = c_zht_lookup(buf, result, &ln);
	if (lret == 0 && ln > 0) {
		Package *lkPackage;
		lkPackage = package__unpack(NULL, ln, (const uint8_t *)result);

		if (lkPackage == NULL) {
			fprintf(stderr, "error unpacking lookup result\n");
		}

		rtn = lkPackage->openmode;
		package__free_unpacked(lkPackage, NULL);
	}

	free(buf); // Free the allocated serialized buffer

	return rtn;
}
int zht_lookup(const char *key, char *val)
{
//	return c_zht_lookup2(key, val);
//	size_t len;
//	return c_zht_lookup2(key, val, &len);

	char *buf; // Buffer to store serialized data
	unsigned len; // Length of serialized data
	char result[ZHT_MAX_BUFF] = {0}; //return result
	size_t ln; //return length

	Package package = PACKAGE__INIT; // Package
	package.virtualpath = (char*)key;
//	package.realfullpath = "";
//	package.has_operation = true;
	package.operation = 1; //1 for look up, 2 for remove, 3 for insert

	len = package__get_packed_size(&package);
	buf = (char*) calloc(len, sizeof(char));
	package__pack(&package, (uint8_t *)buf);

	int lret = c_zht_lookup(buf, result, &ln);
	if (lret == 0 && ln > 0) {
		Package *lkPackage;
//		char *lkBuf = (char*) calloc(ln, sizeof(char));
//		char lkBuf[ln + 1] = {0};
//		strncpy(lkBuf, result, ln);
		lkPackage = package__unpack(NULL, ln, (const uint8_t *)result);

		if (lkPackage == NULL) {
			fprintf(stderr, "error unpacking lookup result\n");
		}
//		else {
//			fprintf(stderr,
//					"c_zht_lookup, return {key}:{value} ==>\n{%s}:{%s}\n",
//					lkPackage->virtualpath, lkPackage->realfullpath);
//		}

//		free(lkBuf);

		strcpy(val, lkPackage->realfullpath);
		package__free_unpacked(lkPackage, NULL);
	}

	//fprintf(stderr, "dfz debug: in zht_lookup(): val = %s. \n", val);
	log_msg("DFZ debug: in zht_lookup(): key = %s, val = %s. \n\n", key, val);

	free(buf); // Free the allocated serialized buffer

	return 0;
}
Exemplo n.º 4
0
job_resource *_create_job_resource(char* jobid_origin_ctrlid)
{
	long num_lookup_msg_local = 0L;
	job_resource *a_job_res = init_job_resource();

	/* get the involved controller list in one dimension array*/
	char *jobid_origin_ctrlid_ctrls = c_calloc(strlen(jobid_origin_ctrlid) + 7);
	strcat(jobid_origin_ctrlid_ctrls, jobid_origin_ctrlid);
	strcat(jobid_origin_ctrlid_ctrls, "ctrls");
	c_zht_lookup(jobid_origin_ctrlid_ctrls, a_job_res->ctrl_ids_1);
	num_lookup_msg_local++;
	c_free(jobid_origin_ctrlid_ctrls);

	/* split the one dimension of involved controller list to two dimension */
	char *ctrl_ids_1_backup = strdup(a_job_res->ctrl_ids_1);
	a_job_res->num_ctrl = split_str(ctrl_ids_1_backup, ",", a_job_res->ctrl_ids_2);

	/* get the allocated nodelist for each involved controller*/
	char *jobid_origin_ctrlid_invid = c_calloc(strlen(jobid_origin_ctrlid) + 30 + 2);

	int i = 0;
	for (; i < a_job_res->num_ctrl; i++)
	{
		strcat(jobid_origin_ctrlid_invid, jobid_origin_ctrlid);
		strcat(jobid_origin_ctrlid_invid, a_job_res->ctrl_ids_2[i]);
		c_zht_lookup(jobid_origin_ctrlid_invid, a_job_res->node_alloc[i]);
		num_lookup_msg_local++;
		c_memset(jobid_origin_ctrlid_invid, strlen(jobid_origin_ctrlid_invid));
	}

	pthread_mutex_lock(&lookup_msg_mutex);
	num_lookup_msg += num_lookup_msg_local;
	pthread_mutex_unlock(&lookup_msg_mutex);

	return a_job_res;
}
Exemplo n.º 5
0
extern void _c_zht_lookup2(char *key, char *ret)
{
    Package package2 = PACKAGE__INIT;
    package2.virtualpath = key;
    package2.operation = 1;
    unsigned len = package__get_packed_size(&package2);
    char *buf = (char*) calloc(len, sizeof(char));
    package__pack(&package2, buf);
    size_t ln;
    char *result = (char*)calloc(1024 * 10, sizeof(char));
    if (result != NULL)
    {
	int lret = c_zht_lookup(buf, result, &ln);
	free(buf);
	if (lret == 0 && ln > 0)
	{
	    //printf("OK, seems fine!\n");
	    Package * lPackage;
	    char *lBuf = (char*) calloc(ln, sizeof(char));
	    strncpy(lBuf, result, ln);
	    lPackage = package__unpack(NULL, ln, lBuf);
	    free(lBuf); free(result);
	    if (lPackage == NULL)
	    {
		printf("error unpacking lookup result\n");
	    }
	    else
	    {
		//printf("The value is:%s\n", lPackage->realfullpath);
		strcpy(ret, lPackage->realfullpath);
	    }
	}
	else
	{
	    free(result);
	}
    }
}
Exemplo n.º 6
0
void test_pass_package() {

	char *key = "hello";
	char *value = "zht";

	Package package = PACKAGE__INIT; // Package
	package.virtualpath = key;
	package.realfullpath = value;
	package.has_isdir = true;
	package.isdir = true;
	package.has_operation = true;
	package.operation = 3; //1 for look up, 2 for remove, 3 for insert

	char *buf; // Buffer to store serialized data
	unsigned len; // Length of serialized data

	len = package__get_packed_size(&package);
	buf = (char*) calloc(len, sizeof(char));
	package__pack(&package, buf);

	/*
	 * test c_zht_insert
	 * */
	int iret = c_zht_insert(buf);
	fprintf(stderr, "c_zht_insert, return code: %d\n", iret);

	/*
	 * test c_zht_lookup
	 * */
	memset(buf, 0, len);
	package.operation = 1; //1 for look up, 2 for remove, 3 for insert
	package.realfullpath = "";
	package__pack(&package, buf);

	size_t ln;
	char *result = (char*) calloc(LOOKUP_SIZE, sizeof(char));
	if (result != NULL) {
		int lret = c_zht_lookup(buf, result, &ln);
		fprintf(stderr, "c_zht_lookup, return code(length): %d(%lu)\n", lret,
				ln);

		if (lret == 0 && ln > 0) {
			Package *lkPackage;
			char *lkBuf = (char*) calloc(ln, sizeof(char));

			strncpy(lkBuf, result, ln);
			lkPackage = package__unpack(NULL, ln, lkBuf);

			if (lkPackage == NULL) {
				fprintf(stderr, "error unpacking lookup result\n");
			} else {
				fprintf(stderr,
						"c_zht_lookup, return {key}:{value} ==>\n{%s}:{%s}\n",
						lkPackage->virtualpath, lkPackage->realfullpath);
			}

			free(lkBuf);
			package__free_unpacked(lkPackage, NULL);
		}
	}
	free(result);

	/*
	 * test c_zht_remove
	 * */
	memset(buf, 0, len);
	package.operation = 2; //1 for look up, 2 for remove, 3 for insert
	package__pack(&package, buf);

	int rret = c_zht_remove(buf);
	fprintf(stderr, "c_zht_remove, return code: %d\n", rret);

	free(buf); // Free the allocated serialized buffer
}